ReSharper 2020.2 Help

What's New in ReSharper

ReSharper 2020.2

  • ReSharper C++ is included in the ReSharper subscription.

  • Ability to reformat code and run code cleanup automatically on save and for recently modified or opened files.

  • Inlay hints in XAML.

  • You can quickly locate usages of any symbol in the solution and referenced assemblies by pressing Alt+F7 (Find Usages of Symbols), Control+Alt+F7 (Go to Usages of Symbol), or Shift+Alt+F7 (Find Usages of Related Entities) in the result lists of Search Everywhere/Go to Type, Go to Symbol, and Go to File Member.

  • New features in the Peek Definition view: Peek Implementations (Ctrl+Alt+middle button click or Control+Alt+Q) Peek Base Symbols (Shift+Alt+Q) Peek Usages (Ctrl+middle button click).

  • New export formats in type dependency and project dependency diagrams: GraphML (for external analysis) and XPS (for printing large diagrams).

  • ReSharper command line tools can be installed and used as .NET Core global tool.

  • EditorConfig support for dotnet_diagnostic rules.

  • The [RegexPatternAttribute], which previously enabled regular expressions assistance for marked parameters, now also works for fields and properties.

  • Improved Blazor support

  • Unit testing improvements:

    • New unified test runner for .NET and .NETCore

    • Support for MSFakes for NUnit, XUnit and MSTest both for .NET and .NETCore tests (Windows only)

    • Support for TypeMock for NUnit, XUnit and MSTest v2

    • Ability to navigate from a test in the editor to tests sessions where it is added.

  • Decompiler: support of expression-bodied members, throw expressions, default parameters, and named arguments.

  • Decompiler: NullablePublicOnlyAttribute support

  • New features in C++:

    • Unreal Engine:
      • Introduced support for the Unreal Engine project model allows ReSharper C++ to better understand different solution configurations, and plugin and module references.

      • Symbols from engine sources are now treated as library symbols and hidden by default from the search results.

      • Several updates to inspection severity, code generation actions, documentation template, and auto-import of include directives according to the Unreal Engine coding standard

      • Reminders to refresh the Visual Studio project in Unreal Editor if the project files are out of date

      • The bundled dictionary is supplemented with a list of common game acronyms and abbreviations.

    • C++/CLI:
    • Go to Declaration works on unresolved identifiers

    • Highlighting of usages of the element under the caret

    • Highlighting of spelling mistakes for preprocessor directives

    • File Structure: preprocessor directives are now hidden by default.

    • New inspections: Structured bindings could be used, Cannot use gcnew on a native type, Cannot use new on a managed type, final specifier cannot be used for managed classes, Overriding function does not have a virtual specifier, You might need to regenerate the project files

    • A brief preview of Clang-tidy quick-fixes

    • Improved support for values of class types in evaluation of constexpr functions

    • Code completion: a new completion item can insert an auto-generated lambda argument when an std::function parameter is expected. If a class is not included in the current file, import completion will suggest a new option to add a forward declaration.

    • New settings: Indent aligned ?: operator, Insert // on Enter in multi-line // comments, Consider only quoted includes as potential main headers

    • New file templates: Source file and Header file

ReSharper/ReSharper C++ 2020.1

  • Nullable reference types support:
    • Compilation warnings related to nullable reference types

    • New inspection and quick-fix to detect redundant type parameter constraints with respect to Nullable Reference Types

    • A number of different quick-fixes for nullability warnings

    • Change signature refactoring is updated to support changing nullability

    • Quick documentation is updated to show nullability annotations

  • New inspection and quick-fix to detect and use async overloads of methods instead of sync when available

  • Configurable code style for trailing commas in declarations with multiple items and similar constructs (object, array, and collection initializers, as well as enums and switch expressions)

  • Go to Declaration works with the middle mouse button.

  • You can locate files in the Solution Explorer by pressing Ctrl+Enter on the selected result in the Go To File list.

  • Export and import of unit test sessions.

  • Localization manager improvements: ability to edit, export and import comments as well as a number of UX and performance fixes

  • Decompiler: improved tuple component names support

  • Decompiler: nullable reference types (in declarations, not in method bodies)

  • Decompiler: default interface members

  • Decompiler: field-targeted attributes for auto-implemented properties and field-like events

  • IL View: support for custom attributes in interface implementations and generic parameter constraints (for example, the compiler can apply NullableAttribute and TupleElementNamesAttribute to these entities)

  • New features for ReSharper C++ 2020.1:

    • C++20:

      • Constrained type placeholders and abbreviated function templates

      • Using enum declarations and the Introduce Using Enum refactoring

      • Support for concepts in the naming and redefinition inspections

    • New inspections: Unused lambda capture, Functional-style cast used instead of a C++ cast, reinterpret_cast used instead of a static_cast when casting to void, Use explicit template parameters in lambda

    • New settings "Case-sensitive sort" and "Group headers by directory" for sorting of includes

    • Code completion improvements: completion of attribute names; label names are shown when completing in a goto statement; postfix completion for std::forward; completing a call to a base function from an overriding function will insert a forwarding call, which passes all function parameters to the base function; completion in macro definitions; Complete statement

    • Typing assist surrounds selected code with parentheses/brackets/quotes after typing the corresponding key

    • "Add [[maybe_unused]]" quick fix

    • Context action to replace UNREFERENCED_PARAMETER with a [[maybe_unused]] attribute

    • Filters in Go to... actions for concepts and namespaces

    • Options in Generate to add a [[nodiscard]] attribute to generated getters and constructors

    • Type name hints are enabled by default in dependent code

    • "Generate mock functions" supports the MOCK_METHOD macro from GTest 1.10

    • Parameter name hints in dependent function calls

    • Better error messages about unsatisfied constraints

    • Unit-testing setting to use files instead of named pipes (useful when named pipes are blocked by antivirus software)

    • Change Signature accepts non-resolving types

    • Major improvements for the Rearrange code actions

    • Clang-tidy is updated to LLVM 10, with new checks and diagnostics

    • Go to Declaration works on symbol names inside comments

    • Improvements in File Structure: icons now have indicators for class member accessibility and virtual/static/pure specifiers, new inheritance icons for class members (shown when a function overrides/implements/hides a base function)

    • Convert to Scoped Enum refactoring

    • Dedicated shortcut Control+OemQuestion for the Document action

    • Unreal Engine 4 support improvements:

      • Renaming a UE4 header will also rename the corresponding *.generated.h #include

      • Renaming a UE4 type will also rename the corresponding header and source files (with A, F, E prefixes)

      • SpatialOS framework support

      • Tweaked default settings for UE4 solution to better match their coding guidelines (avoid suggesting auto keyword)

      • Better support for UE4 naming conventions: naming rules for console variables and for log categories

      • Go to... actions show namespaces that contain UE4 enums

ReSharper/ReSharper C++ 2019.3

  • Improved C# 8 support including: notnull constraint, the target-typed switch expressions, early support for default interface methods, a new hint "Local function can be static", and a new quick-fix "Add missing arms".

  • Localization manager

  • Type name hints for lambda’s parameters, vars including pattern matching and tuples deconstruction, range variables inside LINQ statements, and at the end of a line in a method call chain. Hints for missing returns in functions and missing breaks in switch statements

  • Xamarin support fixes: x:DataType and Class attributes support.

  • Generate type patterns in switch expressions

  • Options to use System.HashCode to implement GetHashCode and to take nullability into account when generating equality members or equality comparer.

  • Parameter Information supports tuples.

  • Reading and exporting C# naming settings from/to EditorConfig.

  • Find dependent code now works for NuGet references and can be run for the whole solution. Also there are new filters for dependent code in find results.

  • Navigate To Consuming APIs

  • Decompilation of tuples, deconstruction, discards

  • Navigation to external sources of NuGet packages using symbol packages (.snupkg).

  • New code inspections and quick-fixes. Among other things, for NUnit tests. 'Type or member is never used' is split into two separate inspections — for types and for members.

  • New grouping and filtering options in the Unit Test Explorer window and Unit Test Sessions window.

  • More colors for different kinds of identifiers in Syntax Highlighting

  • More detailed configuration for code style of using 'var' vs explicit type.

  • ReSharper Command Line Tools can run on Linux and macOS.

  • New features for ReSharper C++ 2019.3:

    • C++20: Initial support for C++20 concepts, ADL and Function Templates that are not Visible, initializing aggregates from a parenthesized list of values

    • Clang-tidy integration improvements:

      • The bundled clang-tidy binary is updated to version 9 with a number of new checks. Additionally, it should no longer prevent modifications to source files.

      • Clang warnings can now be disabled from the inspection menu.

      • A new setting to use a specific clang-tidy configuration file (instead of a setting which specified the configuration as a string)

    • Formatter improvements: export of formatting options to a .clang-format file, options for spaces before ptr and ref in abstract declarations.

    • Thanks to some improvements in the code highlighting engine, re-highlighting now happens faster (after a function’s body is changed, only the body itself will be reanalyzed).

    • New quick-fixes that help adding a variable to the lambda capture list.

    • Unreal Engine 4 support improvements:

      • UE smart pointers (TSharedPtr, TSharedRef, TWeakPtr, TUniquePtr) are supported similarly to std::shared_ptr/unique_ptr (for example, they are supported by the Parameter Info, code analysis, and postfix completion).

      • The new postfix template for UCLASS expands to a proper factory function call.

      • New USTRUCT/UCLASS/UENUM/UENUMCLASS live templates are available.

      • No more Visual Studio hang after executing the "Refresh Visual Studio Project" action in the Unreal Engine 4 editor.

    • Several live templates were renamed to match the corresponding keywords (for example, cls to class, str to struct).

    • A couple of updates in Go to file member: The dialog is now displayed instantly instead of waiting for a file to be fully analyzed, if a file contains both the declaration and the definition of a function, the function is shown only once in the dialog.

    • It’s now possible to navigate to the aggregate class from the opening brace of a brace-enclosed initializer list.

    • New setting to find the clang-tidy executable to use in %PATH%.

    • Inlay hints improvements: Type name hints for auto variables, structured bindings, function and lambda return types. Type name hints are disabled by default in dependent code.

    • Sort #include directives (quick-fix and context action).

ReSharper/ReSharper C++ 2019.2

  • Improved C# 8 support including: the latest changes in indexes and ranges such as indexable and rangeable types, unmanaged generic structs.

  • Go to File Member now also searches for textual matches in the current document.

  • Ability to filter out occurrences in comments in the search results of Go to Text.

  • Ability to exclude symbols from import namespace suggestions and Import Symbol Completion.

  • Solution model is read directly from project/solution files.

  • Usages search works faster by using the indexes of the Solution-Wide Analysis.

  • Tooltips with keyword description in IL Viewer

  • Win32 resources subtree in Assembly Explorer window

  • New features for ReSharper C++ 2019.2:

    • Improved editor hints. There are two new types of hints: hints after preprocessor directives and hints for function arguments passed by a non-const reference. Hints in aggregate initialization expressions now show the names of initialized base classes.

    • More C++ 20 features are supported: conditional explicit, char8_t, pack expansion in lambda init-capture, default constructible and assignable stateless lambdas, C++20 rules for aggregates, consteval and constinit specifiers, C++20 improvements to structured binding declarations.

    • The summary tooltip in code completion is now syntax-colored and shows documentation for the selected item.

    • Improved Unreal Engine 4 support:

      • The Rename and Change Signature refactorings handle UE4 RPC functions properly.

      • Unreal Engine specific code analysis checks especially targeting the missing or incorrectly set UE4 reflection macros

      • Built-in documentation for reflection specifiers is now available in the Quick Documentation popup.

ReSharper/ReSharper C++ 2019.1

  • Visual Studio 2019 support.

  • C# 8 support including: Ranges and index from end expressions, Null-coalescing assignment, Switch expressions, Tuple expression in switch statement, Static local functions, Initial support of using var declarations, Nullable reference types (parsing only), Async streams, Async disposables

  • Go to Text now searches in all text files in the solution.

  • Optimize references now works with SDK projects

  • Extract Method refactoring supports renaming of introduced parameters in the UI.

  • Improvements in Inlay Hints: Hints for attribute usages, special Hints for StringFormatMethod calls (disabled by default), more flexible configuration, auto-hide on column selection, a keyboard shortcut Control+Alt+Shift+5 to show/hide the hints.

  • New features for code annotations and nullability analysis: Typing assist inserts ItemNotNull/ ItemCanBeNull attributes when the caret is within an argument of a generic collection type, Lazy<T>, or Task<T>, Typing assist supports C# 8 nullable reference types allowing to insert or remove the nullable mark ?, Code annotations hints on method declarations.

  • Faster navigation and search: "Instant" types search Faster "Search everywhere" and "Go to type"

  • Formatting and code cleanup improvements: formatting inspections for indenting around child statements are turned on by default, detecting formatting settings now works in background, export settings to EditorConfig, an option to turn off placing System.* and Windows.* namespaces first when rearranging namespace imports, which is now compatible with Visual Studio and StyleCop

  • Typing assist for unindent on Backspace, which returns the caret either by a multiple of the current indent size, or directly to the expected indent position in the code structure.

  • New features for ReSharper C++ 2019.2:

    • Performance improvements: Faster indexing, Smaller memory footprint, Less memory traffic during indexing and code analysis, Faster solution open from cache in large solutions.

    • New language features: C++20 familiar template syntax for generic lambdas, C++17 hexadecimal floating point literals, Alternative operator representations, Basic support for C++20 contracts, and three-way comparison operator.

    • New entity kinds are available when configuring naming rules.

    • Unreal Engine 4 support:

      • Initial indexing with default settings is 6x faster than 2018.3, 2x less managed memory used after indexing, 3x less live objects,

      • Awareness of RPC functions: navigation between them, generating implementation and typing completion,

      • UE4 options page with settings that allow turning off indexing of engine code/third-party code/plugins,

      • Initial support of naming convention defined by Unreal Engine's coding standard,

      • Clang-Tidy Integration is disabled by default for Unreal Engine 4 solutions.

    • New features for unit testing: Support for the doctest unit testing framework, Support for Catch 2.7 (TEMPLATE_PRODUCT_TEST_CASE test declarations) Support for GTEST_SKIP() in Google Test, Environment variable names wrapped with % get expanded in user-provided environment string

    • Improvements in formatting settings: support K&R style declarations in C, separate formatting options for spaces around references and pointers, macro calls get formatted similar to function calls.

    • Highlighting of identifiers in external files.

    • Improvements in navigation and search: Chained 'Go to' searches are several times faster now, Include base members option in Go to file member is supported, "Go to file member", base and derived class searches now work during indexing

    • More features for documentation comments: Parameter names get renamed in XML documentation comments, Typing assist automatically inserts /// on a new line

    • Clang-Tidy Integration improved: Separate clang-tidy options page (Code Editing | C++ | Clang-Tidy), Setting to harness a user-provided clang-tidy binary

ReSharper/ReSharper C++ 2018.3

  • New features for C# 7: Code Inspections, quick-fixes, and Context Actions for tuples, deconstruction, and more.

  • VB.NET 15.3 and 15.5 features support: named tuple inference, leading hex/binary/octal separator, non-trailing named arguments

  • Inlay Hints

  • Use C# naming rules from existing code

  • Use formatting rules from existing code

  • Introduce Parameter refactoring now also works for local functions.

  • External Annotations can be stored under VCS, in the ExternalAnnotations folder next to a solution or a project file.

  • Ability to open options pages with Go to Action Control+Shift+A

  • Configuration options for the usage-aware behavior of Go to Declaration.

  • Integrated decompiler improvements: local functions decompilation; Pattern matching decompilation: const pattern, type pattern, type patterns in the case clauses (predicates and discards are supported)

  • Localization Assistance support in ASP.NET Core apps.

  • New Code Inspections, quick-fixes, and Context Actions for NUnit and xUnit.net tests.

  • Multi-threading mode for the InspectCode Command-Line Tool command-line tool.

  • TypeScript 3.0 syntax support: unknown type (parsing only), optional elements in tuple types, rest elements in tuple types, rest parameters with tuple types, spread expressions with tuple types (without resolve), generic rest parameters

  • New features for ReSharper C++ 2018.3:

    • Automatic detection of formatting settings for C++ code

    • Predefined naming style schemes (STL, Google, LLVM, CamelCase, Microsoft)

    • Performance improvements: improved memory traffic during indexing, multithreaded cache load

    • Navigation improvements: Go to Declaration works more precisely on non-dependent decltype specifiers and lambdas, and you can even use it during the initial indexing

    • Refactorings improvements: Change Signature refactoring gets options to make a function constexpr/const/noexcept and change the ref-qualifiers.

    • Code analysis improvements: error diagnostics in the templated code is improved significantly, providing extra information on failed enable_if conditions, ill-formed expressions inside decltype, and absent inner types.

    • New context actions to generate a function that will convert an enum to a string, convert a regular return type in a function declaration into a trailing return type and vice versa, and also insert template arguments deduced using class template argument deduction.

    • Code generation improvements: Generate Getters/Setters can create C++/CLI properties, Generate Overriding Members can override CLR properties

    • For Unreal Engine projects: postponed background indexing of the engine itself to improve the initial indexing performance and better handling of the reflection macros

    • Unit testing support for Catch 2.5

    • New supported type traits in C++11 std::has_virtual_destructor and in C++/CLI (__is_interface_class, __is_ref_array, __is_ref_class, __is_value_class, __is_sealed, __is_delegate, __has_finalizer)

    • C++20 nested inline namespaces support

    • Improved C++/CLI suppor

ReSharper/ReSharper C++ 2018.2

ReSharper/ReSharper C++ 2018.1

  • Full support of C#7.2, including features missing in previous releases: non-trailing named-arguments, private protected access modifier, leading underscores in numeric literals, in parameter, ref readonly returns and locals, readonly struct type, ref struct type, conditional ref operator.

  • A new way to detect unused non-public members without the Solution-Wide Analysis— the Show unused non-private type members when solution-wide analysis is off option on the Code Inspection | Settings page of ReSharper options (Alt+R O)

  • Code cleanup can be now executed with the free CleanupCode command-line tool.

  • Value Tracking supports some new C# features: ref-returning methods, pattern matching, and out variables.

  • A new filter for unit tests /u in search everywhere Control+N (the most powerful ReSharper's search action, previously referred to as Go to Everything).

  • Configurable 'var' styles and new Code Inspections, quick-fixes, and Context Actions for deconstructing declarations and discards.

  • EditorConfig properties for code syntax styles and code inspection severity levels.

  • Code inspections features for code formatting styles.

  • Initial StyleCop support.

  • Typing assistance improvements: If you press Enter in the middle of a line comment, ReSharper will automatically add two slashes // in front of the text on the new line to avoid getting a non-compilable text.

  • Support for NUnit 3.10.1

  • New features for ReSharper C++ 2018.1 (an extended version is also available in a dedicated blog post):
    • Step filters.

    • Includes analyzer.

    • Clang-Tidy Integration updates: the bundled Clang-Tidy has been updated to version 6.0, which extends the list of avaialble checks and specific Clang-Tidy checks can now be suppressed with a comment.

    • The #include_next preprocessor directive is now supported, for better compatibility with compilers that implement this GNU extension.

    • Typing assistance in C++ files automatically removes trailing whitespaces on Enter in order to keep your code clean of redundant whitespaces.

    • If you select an expression and open the Quick Documentation window for it, the window show various information about the selected expression, such as its type, value, and value category.

ReSharper/ReSharper C++ 2017.3

ReSharper/ReSharper C++ 2017.2

ReSharper/ReSharper C++ 2017.1

ReSharper/ReSharper C++ 2016.3

  • Support of Visual Studio 2017 RC, including the new .csproj based .NET Core projects.

  • Massive improvements in Language Injections: JavaScript, CSS, and JSON are supported, ability to inject languages with a comment /*language=javascript|html|regexp|jsregexp|json|css*/, ability to disable automatic language injections in specific cases.

  • A new Transform Parameters refactoring, which combines and replaces two other refactorings 'Transform Out Parameters' and 'Extract Class from Parameters'.

  • No more separate setting pages for Context Actions in specific languages as all of them can be now enabled or disabled on the Code Editing | Context Actions page of ReSharper options.

  • Redesigned inspections severity options page (Code Inspection | Inspection Severity).

  • New options page (Code Editing | Third-Party Code), which allows adding C++, JavaScript, TypeScript, CSS, HTML and JSON files, folders and wildcards to be treated either as 'skipped' or 'library'. ReSharper will completely ignore 'skipped' files, and treat 'library' files as read-only — indexed for navigation, but no inspections, quick-fixes and refactorings.

  • The Usages of Symbol action lets you switch from the popup to the Find Results window before the usage search is over.

  • The Find Results window works asynchronously, meaning that you can work with the results tree while a search is in progress.

  • Recent Files and Recent Edits pop-ups now show the path of the file, Recent Edits can also show all edits in the same method as a single entry.

  • New formats of content files (.less, .hbs, .coffee, .scss, .dart, .as, .styl) supported in Go to Text.

  • A setting to remember the last search in Search Everywhere/Go to Type, Go To File, and Go to Text actions (this behavior is turned off by default).

  • Assembly Explorer window adds a new way to load assemblies – directly from nuget.org or from any NuGet package source.

  • New code generation actions: relational members, relational comparer, dispose pattern, plus a new option to check parameters for null in generate constructor.

  • New quick-fixes and context actions: e.g. a new quick-fix to introduce fields and auto-properties for all unused parameters; a new context action on fields of type Lazy<T> will introduce a property to encapsulate fieldname.Value.

  • A new typing assist for interpolated strings: type $ and ReSharper will automatically complete the $"" and insert the text caret between the quotes.

  • Join Lines command that quickly appends the next line after the current one.

  • ReSharper build improvements: the results of a build are now displayed in their own Build Results window, plain text logging to the Output window and/or to a file, an option to automatically run build after the solution is loaded, and proprietary NuGet package restorer that works with all supported Visual Studio versions.

  • External stack traces can open automatically in the Stack Trace Explorer window.

  • Initial support for C# 7.0 and VB.NET 15 features: binary literals, digit separators, out variables, local functions, and more.

  • Dynamic completion of package names in project configuration files (project.json, package.json, and bower.json).

  • Unit testing assistance is now available for for NUnit and xUnit.net unit tests in ASP.NET Core and .NET Core projects.

  • Significant performance improvement xUnit.net tests.

  • Support of UWP RelativePanel control.

  • Formatter improvements: Indenting of nested for, foreach, while, lock statements without braces is now disabled by default, with options to restore the old behavior; new option for indenting type parameter constraints; fixes for bugs introduced in 2016.2 by the new indenting engine.

  • Reworked coloring of to-do items in the editor.

  • Improved TypeScript/JavaScript support including:
  • New features for ReSharper C++ 2016.3:

ReSharper/ReSharper C++ 2016.2

  • Support of ASP.NET Core 1.0 and .NET Core 1.0 projects.

  • Go to Text.

  • Structural Navigation.

  • Warnings in Solution-Wide Analysis.

  • New C# typing assistant features: dot/semicolon inside parentheses and auto-correction of prefix in verbatim string interpolation

  • Ability to mark references as used at runtime to exclude them from cleanup performed by the Optimize References and Remove Unused References features.

  • Rearrange code improvements. For example, it is now available in interpolated string inserts, and in expressions with 3 and more operands; greedy brace now works for opening brace, braces of types and namespace declarations.

  • Reworked surround templates: each non-file template can now be used for generating code, for surrounding code, or for both, which lets you reuse your custom surround templates as live templates and vice versa, reducing their total number.

  • Extract Members to Partial refactoring.

  • Move Type to Another File refactoring can be now applied to nested types.

  • Assembly dependency diagram.

  • Ability to suppress custom code inspections with comments: specify a 'suppression key' in the Edit Highlighting Pattern dialog, and then use comments like // ReSharper disable once [SuppressionKey].

  • Execution log in the Unit Test Sessions window that lets you separate problems related to test execution process from unit tests code.

  • HTML analysis inside string literals in .cs, .js, and .ts files, which is enabled with the context action or with a comment /*language=html*/ before the string literal.

  • Ability to enable regular expression assistance in string literals with a comment /*language=regexp*/ before the string literal.

  • JSON value helpers.

  • Support for the <inheritdoc/> tag in XML documentation comments.

  • C# formatter improvements: new options for indenting of parentheses and code inside them; for controlling spaces before and after ++ and -- operators as well as before and inside parenthesis of checked and default expressions.

  • IL Viewer improvements: when you set the caret on a code symbol or instruction, all usages of this item are highlighted; loops in your code can be distinguished by corresponding indents and comments.

  • Ability to explore assemblies from currently running processes.

  • Localization Inspections and quick-fixes as well as the Move to Resource refactoring now work for interpolated strings.

  • VB.NET: support for interpolated strings

  • CSS: support of custom properties and CSS variables.

  • Improved TypeScript/JavaScript support including:
    • Generative Completion in TypeScript (ctorf/ ctorp, overrides, lambdas).

    • Full support of TypeScript 2.0 features, including this for functions, control-flow aware type guards, path mappings, optional class members, the never type.

    • Generating implementations for abstract members declared in a parent class using the Generate action Alt+Insert or a quick-fix.

    • Go to Declaration and Find Usages work correctly when dealing with type aliases.

  • New features for ReSharper C++ 2016.2 (an extended version is also available in a dedicated blog post):
    • C++14 language features: variable templates and decltype(auto).

    • Warnings about usages of classes and functions marked with the [[deprecated]]/__declspec(deprecated) attribute.

    • Support of the [[noreturn]]/__declspec(noreturn) attribute in control flow analysis.

    • New code style preferences for include directives in generated code.

    • Inline Variable refactoring now works in C++.

    • Important optimization of code analysis. For example, this optimization makes indexing (first opening) of the Unreal engine project several times faster.

    • Automatic Completion in C++ now also suggests symbols that are not included in the current file.

    • New code inspections and quick-fixes: 'Missing include guards' in your header files with the 'Add #pragma once directive' fix; 'Non-explicit conversion operator'; inspection and a fix to add a missing default case to a switch statement.

    • The Document context action that allows you to quickly add documentation comments to types and symbols.

    • When your caret is on one of a function’s exits (return, throw, etc.) ReSharper will automatically highlight all other function exits including exits from loops and switch statements.

    • A code style preference for using 0|nullptr|NULL in default pointer initializers.

    • New formatter options: single-line functions and lambdas, Blank lines around single line function definitions, Break line before member initializer list, Space between closing angle brackets in template arguments (for conformance with pre-C++11 compilers)

    • __RESHARPER__ macro that allows you to detect when ReSharper is parsing your source code and, if necessary, disable ReSharper's preprocessor for some code.

    • Quick Documentation and Parameter Information pop-ups can display documentation from documentation comments optimized for Doxygen.

ReSharper/ReSharper C++ 2016.1

ReSharper/ReSharper C++ 10.0

ReSharper 9.2/ReSharper C++ 1.1

ReSharper 9.1

ReSharper 9.0

ReSharper 8.2

ReSharper 8.1

ReSharper 8.0

ReSharper 7.1

ReSharper 7.0

ReSharper 6.1

ReSharper 6.0

ReSharper 5.0

ReSharper 4.5

ReSharper 4.1

  • Support for Microsoft Visual Studio 2008 SP1.

  • ASP.NET enhancements.

  • Improved performance and usability.

  • Bug fixes.

ReSharper 4.0

  • Comprehensive support for Visual Studio 2008 and C# 3.0, including LINQ, implicitly typed locals and arrays, extension methods, automatic properties, lambda expressions, object & collection initializers, anonymous types, expression trees, and partial methods.

  • Errors, warnings and suggestions are complemented by hints, which are by far the most non-intrusive way to recommend coding improvements.

  • .NET Framework classes were annotated with custom attributes to make ReSharper analyze your code even better than before - for instance, to let it know where format strings should be passed or where null values can or cannot be assigned. You can also use these custom attributes to annotate your own source code, as well as library symbols that you don't have source code for.

  • Code Cleanup - a powerful successor to Reformat Code. By running Code Cleanup, you can instantly apply a dozen of actions, including arranging 'this' qualifiers, removing code redundancies, migrating to auto-properties, optimizing using directives, and many more.

  • All ReSharper refactorings now support C# 3.0. New members of the refactoring family are available, including Convert Method to Indexer refactoring, Convert Indexer to Method refactoring, Convert Static to Extension Method refactoring, Convert Extension Method to Plain Static refactoring, Convert Property to Auto-Property refactoring, Convert Anonymous to Named Type refactoring, and Inline Method refactoring. All refactorings that are not C# 3.0-specific are now available for Visual Basic 8.

  • Complete Statement - a new feature that inserts necessary syntax elements (braces, semicolons etc.) and gets you to the position to start the next statement.

  • CamelHumps in Code Completion. All three completion features - Basic Completion, Smart Completion, and Import Symbol Completion - let you complete any symbol by entering only its uppercase characters.

  • Templates Explorer and Template Editor - a redesigned set of tools to view, manage, and edit the three types of templates that ReSharper provides. From now on, you can manage and classify your templates in a special-purpose window, and edit them right in a Visual Studio code pane.

  • Recent Edits - a drop-down list similar to existing Go To features that shows files and symbols that you recently modified.

  • Go to Type / Symbol / File features allow you to display destination types/symbols/files in the Find Results window.

  • To-do items are now discoverable in identifiers and strings.

  • File Structure, Go to File Member, and Go to Next/Previous Member all support XML and XAML.

  • Vast improvements in Quick Documentation, including hyperlinks to related items, back/forward navigation, "read more" links and navigating to source.

  • Smoother interaction with Visual Studio ecosystem. The quality of interaction with frameworks, add-ins, version control clients and other members of the Visual Studio ecosystem (.NET Compact Framework, BizTalk, and Silverlight included) is brought to a new level.

  • ASP.NET Speedup. ReSharper 4.0 significantly speeds up analysis and, consequently, editing of ASP.NET pages, to enable more web developers benefit from the great toolset that ReSharper provides.

ReSharper 3.1

ReSharper 3.0

  • Comprehensive support for VB.NET: versatile code assistance, code completion, many important code refactorings, code generation, live templates, and more.

  • Full-fledged C# code analysis with code suggestions that go beyond just bringing your attention to errors and propose optimized code usage.

  • Cross-language functionality: for mixed C# and VB.NET projects, ReSharper helps you keep all parts of code working together smoothly and navigate around your code with ease.

  • Three editions of ReSharper (C#, VB.NET and Full) for different target audiences.

  • To-do list: create to-do items by certain patterns and navigate between them.

  • Type members preview: you can now preview existing members of a selected type, either all or polymorphic only.

  • Auto member reordering: define the order of members in the Options dialog.

  • Ability to find code dependent on specific module and find usages of symbols external to scope.

  • Go To Symbol for robust solution-wide search by name for any file member.

  • Disabling warnings at a specific position: configure the "Disable warning" context action and apply it where necessary.

  • Unit Test Explorer window: unparalleled flexibility in running and debugging unit tests.

  • XML and XAML support.

Last modified: 24 September 2020