ReSharper version history

Initial support of C# 13.

A number of improvements of AI Assistant, including AI code completion, exception explanation, and custom global prompt.

Ability to change the user interface language to Chinese, Japanese, or Korean.

Inlay hints for closing braces.

Add/Remove params modifier refactoring.

Preview of different cultures for ToString() format specifiers.

Integrated decompiler improvements:

• Decompiler: default and params lambda parameters (C#12: Lambda optional and parameter-array parameters)

• Decompiler: attributes on lambdas

• Ability to decompile protected assemblies and ignore the [SuppressIldasm] attribute

• Support of PDBs containing both SrcSrv and SourceLink

• Get preprocessor directives (like NET6_0_OR_GREATER) for external source files from the target framework of associated assembly or from Portable PDB of associated assembly

• Assembly Explorer: assembly build configuration detection and presentation

• Ability to open the source code of the corresponding repository in the Web browser, for example, on GitHub.

New features in C++:

• C++23 support: multidimensional subscript operator, the #elifdef and #elifndef C++23/C23 preprocessor directives, and the [[assume(<expr>)]] attribute.

• Unreal Engine: support for struct traits, inspections for usages of IOnlineSubsystem::Get () and missing calls to base methods.

• Type layout in quick info tooltips.

• Improvements to the Rename refactoring.

• Support for include-what-you-use pragmas.

• The bundled Clang-Tidy binary has been updated to Clang 18.

A number of improvements of AI Assistant, including AI code completion.

Improved performance of the Rename refactoring.

New UI for naming style settings.

The default output format of InspectCode is changed from XML to SARIF. XML output is still available with the -f="xml" parameter.

Task<T> and ValueTask<T> support in the Dispose analysis.

Ability to decompile .NET assemblies in the WebCIL packaging format support.

Dedicated tool window for the assembly diff.

New features in C++:

• Call Tracking now supports outgoing call chains.

• C++20 modules: improved performance and support for internal module partitions.

• Unreal Engine:

  • Support for the Slate UI framework.

  • Completion offers asset paths when completing resource names in C++ code.

  • Interfaces are now supported in HLSL shader code.

• Improvements for the clang-format integration include support for GNU built-in style and the IndentAccessModifiers and DisableFormat format style options.

• Change signature offers new features, including the ability to change a parameter type between a pointer, a reference, or a value type.

• Grazie spell-checking in doc comments.

• New settings to configure the style of documentation comments (ReSharper | Options | Code editing | C++ | Code generation).

• New formatter options: "Break line after goto labels", "Indent goto labels", arrangement of enumerators, "Do not change" for empty braces formatting.

A number of improvements of AI Assistant, including AI code completion.

Updated grammar and spelling check engine.

Create Unit Test can generate test content with AI.

Better support of using aliases (both pre-C# 12 and C# 12).

Support for C# 12 Interceptors, including dedicated code inspections and inlay hints.

Dispose analysis

New code annotation attributes: [MustDisposeResourceAttribute], [HandlesResourceDisposalAttribute], [IgnoreSpellingAndGrammarErrorsAttribute], [TestSubjectAttribute], [MeansTestSubjectAttribute].

Entity Framework support improvements: EF relationships diagram and new code inspections.

Reworked templating for file header style.

Updated UX in refactorings for converting local to global usings and back, and for extracting local functions.

Performance improvements. For example, Find usages of types/constructors is faster when there are a lot of target-typed object creations, which also makes other features like refactorings faster.

Assembly diff improvements: comparison of NuGet packages, folders, and archives; configurable diff modes; auto-detection of Beyond Compare, WinMerge, P4Merge, and Meld as diff tools.

Assembly Explorer window improvements: show all files and folders inside NuGet packages; show content size and type (file extension) Win32 resource nodes.

New features in C++:

• Code completion inside inactive preprocessor branches.

• Find Usages shows possible usages in macro bodies and inactive code.

• Support for the __pragma(pack) syntax, various clang intrinsics, the special preprocessor operator __has_cpp_attribute, and several new C99 and C23 features like the restrict type qualifier.

• Unreal Engine:

  • New inspection for dynamic delegate functions not marked with the UFUNCTION macro.

  • The Generate hash function action now generates code in the Unreal Engine style.

• Support for HLSL templates.

• Attributes with the [[jetbrains::...]] prefix to refine inspections.

• A new Generate destructor action.

• The bundled clang-format and clang-tidy binaries have been updated to Clang 17.

• Support for #pragma region and #pragma endregion: inlay hints, the ability to jump between matching directives, and folding and navigation in the File Structure window.

• New inspections: Conditional expression can be simplified, Multi-character character literal, and set of inspections for incorrect usage of the export keyword in C++20 modules.

C# 12 preview support: primary constructors support for non-record classes and structs.

AI Assistant.

Predictive debugger.

Interactive debugger adornments for intermediate results in LINQ expressions.

New code inspections with corresponding quick-fixes to report and fix:

redundant nullable directive, return of a variable captured by 'using' statement, return of a task produced by 'using'-captured object, conflict of the discard and a variable named _.

New inlay hints in C# for component names of tuples and deconstruction patterns, discard type names, description of warnings disabled or restored with #pragma, implicit return or continue created by a local function at the end of a block.

Improved navigation from the var to possible underlying types.

Improved support of raw strings (new code inspections, quick-fixes, context actions, and typing assistance)

New code inspections and navigation actions in Entity-Framework-related contexts.

Ability to generate unit test stubs for classes and to navigate between tests and tested code.

Ability to compare two assemblies.

New features in C++:

• Safe Delete refactoring.

• C++23 support: if consteval, static operator() and operator[], and C++23 standard library modules.

• C++20 support: [[no_unique_address]] attribute, implementation of C++20 defect report for char8_t, and polished modules support, including recognizing .cppm files as module interfaces and experimental support for modules located outside the project folder.

• Unreal Engine: performance improvements for indexing Blueprints, smart completion for wrapper types with standard assignment semantics, and support for the UE_INLINE_GENERATED_CPP_BY_NAME macro.

• New inspections: Redundant dereferencing and taking address, Redundant template arguments, ISO C++ forbids forward enum declarations without underlying type.

• Improved code completion when the type is restricted by a concept or a trait.

• Gutter marks for recursive calls.

• More consistent and straightforward Go to Declaration.

• Updated bundled clang-tidy and clang-format binaries.

• Context actions to move a template parameter constraint to the requires-clause and vice versa.

• Improved compatibility with GCC and Clang compilers and libc++/libstdc++ standard libraries.

New code inspections and quick-fixes, for example, remove empty regions, replace span.SequenceEquals("stringLiteral") with span is "stringLiteral", extract common property pattern, reduce number of collection lookups.

Syntax style for null checking patterns (not null vs { }).

Parameter name hints for unit test data attributes.

Ability to hide type conversion hints for specific conversion patterns.

Text filter in Unit Test Explorer and Unit Test Sessions is now taken into account when executing tests.

You can use the Rename refactoring to rename files. If a file contains a type with the same name, the type can be renamed accordingly.

Active development of productivity features for CSS is suspended, and these features are disabled by default. To enable them, use the corresponding checkbox on the Environment | Products & Features page of ReSharper options Alt+R, O.

New features in C++:

• Call tracking for incoming calls.

• Macro substitution previews in tooltips and Quick Documentation popups.

• Updates for C++20 modules:

  • Find usages now lets you find all locations where a given module is imported.

  • The Rename refactoring helps you safely rename modules and module partitions, updating all the relevant declarations and imports in your code.

  • The code formatter and Rearrange code now handle export blocks and exported entities.

  • Code completion suggests the module-related keywords and names of known modules.

• Support for C++23 features:

  • Deducing this (P0847).

  • auto(x) and auto{x} (P0849).

  • Empty parentheses () in lambdas are now optional in many cases (P1102).

  • Alias declarations are now allowed in init statements (P2360).

  • Labels are now allowed at the end of compound statements (P2324).

• Support for __VA_OPT__.

• Unreal Engine:

  • File templates for adding a simple or complex test.

  • Mappings for shader source directories.

  • UINTERFACE live template.

  • A new completion item to generate a lambda expression where a delegate, TFunction, or TFunctionRef argument is expected.

• New inspections: Template parameter is never used, typedef /type alias is never used, Redundant base class initializer, Function result of type HRESULT/NTSTATUS should be used, Pass value parameters by const reference, Class Template Argument Deduction failed.

• Improvements for the compile-time evaluation engine, including the evaluation of range-based for loops and better support for unions.

• Context actions for refactorings.

• A quick-fix to create a parameter from an unresolved identifier.

• If you need to extract a one-line function, you no longer have to select the whole line, since the Extract method refactoring now extracts the current line when no selection is active.

• Change signature can now be invoked while the caret is anywhere in the function signature instead of just on the name of the function, as was previously the case.

• A new postfix template allows you to quickly make a const reference with std::as_const or AsConst.

• Comments beginning with /* are no longer auto-closed with */ by default. You can enable auto-insertion of the closing comment with the new Insert */ after /* typing-assist option.

• By default, file paths are put before folders when sorting #include directives.

Early support for Microsoft Visual Studio running on ARM64.

Detection of vulnerable dependencies in NuGet packages.

C# 11 Support: C# 11 file-local types, static virtual members, ref fields, scoped keyword C# 11 UTF-8 literals; a suggestion to use unsigned right shift >>> operator, suggestion to use pattern matching on instead of Span.SequenceEqual("literal"), language injection inside C# 11 raw strings, and more.

Support of .NET 7 [StringSyntaxAttribute] and its different syntax for language injection and code completion.

Import of type dependency and project dependency diagrams in the GraphML format.

Automatic verification of installed extensions.

Decompiler improvements: generic attributes, static abstract and static virtual members in interfaces, user-defined checked operators, unsigned right-shift operator.

Low-level/high-level C# code in the IL Viewer.

New features in C++:

• Experimental support for C++20 modules.

• Unreal Engine:

  • Renaming Unreal Engine entities with Core Redirects.

  • Inlay hints for the BlueprintCallable functions.

  • ReSharper no longer offers unwanted entities from system headers and shader files in auto-import suggestions.

• Ability to format and reformat code with clang-format formatting engine.

• C++ support:

  • C++20 version of the [[nodiscard]] attribute: [[nodiscard("should have a reason")]].

  • GNU style of specifying calling conventions in function declarations.

  • __atomic* and __sync* GCC builtins.

  • #pragma pack directive.

  • Improved compile-time evaluation now correctly handles various forms of object initialization, including the evaluation of constructors of any kind and designated initialization.

  • Parameter info and inlay hints in emplace-like and make-like calls are now available for any function that implies a constructor call.

• Improved clang-tidy integration.

• Origin of a function in parameter info and other tooltips.

• Context actions to improve readability of conditions.

C# 11 Preview support: checked operators, list patterns, required members, raw strings, checked operators, unsigned right shift, span pattern matching, auto-default structs

Automatic cleanup of temporary files.

Structural Search and Replace patterns and replacement templates based on the [CodeTemplate] attribute can be applied in the desired scope (file, project, or solution).

Improvements in the INotifyPropertyChanged support.

Some solution-wide refactorings are available from the action list (Alt+Enter): Extract Method over selected statements; Change Signature, Transform Parameters, Convert Property To Method on member signatures; Convert Static to Extension Method on signatures and on the first parameter.

Dedicated presentation features for ReadyToRun and NGen assemblies in Assembly Explorer window.

Active development of productivity features for JavaScript, TypeScript, and JSON is suspended, and these features are disabled by default. To enable them, use the corresponding checkboxes on the Environment | Products & Features page of ReSharper options Alt+R, O.

Virtual Formatter

New features in C++:

• Unreal Engine:

  • Performance boost for Unreal Engine indexing.

  • Blueprints support: new inlay hints and inspections.

  • Support for Spec tests.

  • Widget metadata specifiers in the code completion list.

• Improved error rendering: syntax highlighting in tooltips and more precise error highlighting range.

• Updated Boost.Test support and fixed issues with data-driven test cases.

• Better handling of emplace - and make-like function calls, including Unreal Engine Emplace calls.

• Creating a documentation stub by pressing Enter inside a /**/ comment before the entity you wish to document.

• Support for the "Public Include Directories" and "All Header Files are Public" project properties.

• The bundled Clang-Tidy binary has been updated to Clang 14, adding new checks.

C# 11 support: Generic attributes.

Extract Global Using/Inline Global Using refactorings.

Support for moving preprocessor directives along with the moved type in the. Move Type to Another File refactoring.

Convention-based routing support for ASP.NET Core.

Detection and automatic configuration of syntax styles.

[MemberNotNull] and [MemberNotNullWhen] annotations are now supported in projects that do not use nullable reference types

Improved support of nullable reference types.

XML Doc comments for platform assemblies, including assemblies with names that differ from the names of the XML documentation files (for example System.Private.CoreLib).

XML documentation in decompiled / metadata view file header.

Forwarded types in the Assembly Explorer window

Improved PDB navigation (sources from symbol files) for types without sequence points such as interfaces and enums.

Ability to explore metadata of assemblies and portable PDBs.

InspectCode Command-Line Tool can produce inspection results in the Static Analysis Results Interchange Format (sarif).

New features in C++:

• Unreal Engine:

  • Quick Documentation now includes a link to the Unreal Engine documentation.

  • The Rename refactoring now updates both the U and I interface classes.

  • The improved code generation for delegate functions substitutes the parameter names from the signature.

• Unit Testing:

  • Support for the Unreal Engine testing framework.

  • Updates for Catch2 v3 and the latest versions of GoogleTest, Boost.Test, and doctest.

• ReSharper C++ is now better at handling implicit constructor calls, thereby improving the search and navigation features for the following cases:

  • smart pointer creation via both standard and Unreal-specific functions,

  • emplace-like container methods,

  • static_cast and c-style cast expressions.

• Improvements for the multiline generation of boilerplate code for aggregate initialization using C++20 designated initializers.

• Updated formatting for the C++20 requires-expressions and a new Line feed at the end of file option.

Support of Visual Studio 2022.

C# 10 support including dedicated features for file-scoped namespaces, CallerArgumentExpression attribute, and global using directives.

Improvements for nullable reference types support.

New inspections and quick-fixes that help to deal with static local/anonymous functions with closures, simplify string interpolation, transform object initializers to constructors with parameters, find inconsistent locks on fields, and more.

Improved performance of fix in scope, as it now uses the results of solution-wide analysis to skip skip irrelevant code.

Go to Type of Symbol navigates to interface implementations in debug mode.

Integral arithmetic analysis supports all C# integral numeric types — int, uint, byte, sbyte, short, ushort, long, and ulong

[CodeTemplate] attribute that helps report and update deprecated APIs.

[RequireStaticDelegate] attribute that encourages allocation-less code patterns.

Find Usages Alt+F7 works for user-defined implicit conversion operators.

Reworked UI , customization options and a new shortcut Control+Alt+Shift+C for copying code references.

More configurable rules for C# formatter.

Support of code style and inspection configuration via .globalconfig files.

Improvements for inheritance gutter marks including the option to switch between ReSharper and Visual Studio marks.

A way to mark injected languages in parameters, fields, and properties via the [LanguageInjection] attribute.

Highlighting of logical and conditional operators under the caret.

Decompiler improvements: support for async disposable, records, and record structs

New features in C++:

• C++20:

  • Code completion to quickly generate boilerplate code for aggregate initialization using designated initializers.

  • Modernizing inspections to adopt the new standard library features: functions for erasing elements from any standard container (std::erase and std::erase_if), checking whether an element exists in an associative container (std::contains), and creating smart pointers with default initialization (std::make_shared_for_overwrite and std::make_unique_for_overwrite).

• Unreal Engine:

  • All predefined templates for Unreal Engine classes are available in the list of ReSharper file templates.

  • ReSharper now works correctly with the Unreal Engine Sparse Class Data system.

• The Parameter Info tooltip displays evaluation results for constant expressions.

• New inspections with quick-fixes: Redundant parameter list in lambda declarator, Redundant elaborated type specifier, For-loop can be replaced with while-loop, Namespace definition containing single class specialization, May be missing keyword throw, [[nodiscard]] cannot be applied to functions without a return value, Abstract final class is marked final or sealed, Non-overriding virtual function is marked final or sealed.

• File Structure groups symbols that have the same qualifier in qualified names.

• Change Signature lets you control the [[nodiscard]] attribute.

• C support: C11 _Generic expressions, the typeof GNU extension.

• Go to Declaration can navigate from a goto statement to the corresponding label and search for declarations in inactive preprocessor blocks.

• Doxygen comment generation on typing ///.

• The bundled Clang-Tidy binary has been updated to Clang 13, adding new checks.

Nullable reference types support:

• New inspections, quick-fixes, and context actions, for example redundant nullable warning suppressions.

• Improved support for parameter names in the [NotNullIfNotNull("param")] attributes.

• Improved support for generics.

• A new refactoring to change nullability.

• A new action to find nullable warning suppressions in file/project/solution is available from a suppression expression.

Source generators support

• Support for source generators in VB.NET

• Source generated files are now supported in Solution-wide analysis.

• All relevant ReSharper features are supported in source generated files — code inspection, navigation features, refactorings, inlay hints, and so on.

• Improved support for results from source generated files in Find Usages.

New inspections, quick-fixes, and context actions. For example, a suggestion to replace new EventArgs() with EventArgs.Empty.

ConfigureAwait analysis.

Support of the generated_code property in .editorconfig to ignore generated code.

Go to Declaration invoked in debug mode on a usage of an interface member can navigate to its actual implementation used in the current frame.

Go to Derived Symbols displays members in derived classes that hide the member you're navigating from.

InspectCode Command-Line Tool automatically restores NuGet packages and builds the solution before starting the analysis.

An option to turn off CPU-intensive coding assistance features in Razor.

Naming style improvements: support of custom naming rules for records, extension methods, and catch variables.

Speedup of code analysis for members with lots of local functions and closures.

Built-in decompiler improvements:

• Single-file apps support (executables published with the 'Produce single file' option, both self-contained and framework dependent) for .NET Core 3.0, .NET 5, and .NET 6 preview (bundle header version 1.0, 2.0, and 6.0).

• Platform-specific executables (app host; 'Produce single file' false) can be added to the Assembly explorer. The corresponding managed assembly will be shown inside the app host node.

• Async streams support (async iterators, await foreach) are supported by the decompiler.

New features in C++:

• Inline Function refactoring.

• Type conversion hints.

• New immutability inspections: Parameter can be made reference to const, Parameter can be made pointer to const, Variable can be made constexpr.

• New modernizing inspections: Structured binding can be used instead of tie(..), Type trait can be simplified using a template alias or a variable template, std::size can be used, Zero initialization can be used instead of memset.

• Unreal Engine:

  • Support for Unreal Engine 5.

  • Code completion now suggests the list of available modules and plugins.

  • Inspections and quick-fixes for missing module and plugin dependencies.

  • ReSharper now inserts the Super call when you generate an overriding function.

  • 10% faster indexing of the Unreal Engine code base.

• Context actions to convert any string into a C++11 raw string literal and vice versa.

• Unindent on Backspace.

• Quick Documentation now includes a link to cppreference.com.

• New settings to configure code generation for function definitions.

• The bundled Clang-Tidy binary has been updated to Clang 12, adding new checks.

Record types are supported by most features, for example, Extract Interface refactoring, Extract Superclass refactoring, Find Usages as well as multiple inspections, quick-fixes, and context actions.

New inspections, quick-fixes, and context actions. For example, a suggestion to convert !() into is not.

Naming style improvements:

• Sort user rules so more specific rules have higher priority.

• Read and write user rules to/from EditorConfig

New refactoring to rename tuple components

Structural navigation, refactoring, inspections, and quick-fixes for ASP.NET Core route templates

Type conversion hints for tuple conversions.

'Navigate to Windows Explorer' action

New formatter settings for:

• spaces before and within target-typed new() parentheses,

• wraps before the assignment operator,

• outdents in label statements.

Unit testing improvements

• Performance improvements in JavaScript and TypeScript tests and QUnit version 2.14.0 support.

• Support for bUnit - a testing library for Blazor components.

• Support for custom test frameworks that use Visual Studio test adapter extensibility.

• MSTest support in Universal Windows Platform projects for Visual Studio 2019

• Better control over spawned processes

• Code inspections for AutoFixture library in NUnit.

New constraint Body in File Layout patterns allows distinguishing between block- and expression-bodied members.

Copy FQN also allows copying GitHub links.

New features in C++:

• C++ support:

  • Class types in non-type template parameters

  • C++20 class template argument deduction rules

  • noexcept as a part of the function type

  • New code completion items for coroutines are available both in basic code completion and as postfix completion templates: co_await, co_yield, and co_return.

• Unreal Engine:

  • Initial support for Unreal Engine 5

  • Support for the RIGVM_METHOD reflection macro

  • The Cast postfix template

• Set of syntax style settings with accompanying inspections, quick-fixes, and context actions.

• Code cleanup updates: new code cleanup tasks, the Cleanup selection context action.

• New inspections: Template arguments can be deduced, Variable can be moved to inner scope, Redundant cast expression.

• New quick-fixes for conversion errors.

• Stop list and separate options page for aggregate initialization hints.

C# 9 support:

• Top-level statements

• Native ints

• Target typed conditional expressions

• Static lambdas

• DynamicallyAccessedMembersAttribute support

• Init-only setters

• with-expressions and records

• Attributes on local functions

• Support for lambda discard parameters

• Source generators

• Target-typed new

• Covariant returns

• Extended partial methods

• Extension GetEnumerator

• Initial function pointer types support

Fuzzy search in Go to Text.

Inlay hints improvements: Push-to-Hint, type conversion hints, better heuristics and context menus for XAML hints, ability to change font size, reworked settings pages.

Structural remove.

Ability to jump out of closing brackets and quotes with Tab.

New C# syntax styles: 'new()' vs 'new T()' and default' vs 'default(T)'.

Support of the Avalonia framework.

Dynamic Program Analysis (DPA).

Unit-Testing: Run test using selected target framework directly from the editor.

Syntax-coloring in the identifier tooltips.

CleanupCode Command-Line Tool console tool can now be run on specified set of files or folders, without pointing to solution file.

Private Source Link support.

Decompiler improvements: Static local functions, top-level statements, attributes on local functions, readonly instance members on structs.

IL Viewer window: improvements in synchronization and context highlighting.

Assembly Explorer window: top-level entry point item (presentation, double-click/context menu navigation, properties).

Go to File Member in library code retains the presentation mode for external sources (decompiled code / code from symbol files / metadata view).

TypeScript support: nullish coalescing and optional chaining

New features in C++:

• Unreal Engine:

  • UnrealHeaderTool integration

  • Live tracking for Unreal Engine properties

  • Control-flow analysis for HLSL

  • New reminders to regenerate the project files

  • Unreal Engine coding standard: default 4 characters tab size, MoveTemp for casting to an rvalue reference

• C++20

  • Comparison rules

  • The ranges library

  • Support for the standard mode of C++20 coroutines introduced in Visual Studio 16.8

• New inspections: An algorithm operating on ranges can be used, std::views::keys/values can be used, Algorithm accepting an iterator and a count can be used.

• Import Completion:

  • The completion list now includes suitable members of incomplete classes.

  • There is a new option to add an elaborated type specifier for the corresponding class.

• Context action to invert a ternary expression

• Go to Declaration can be used to jump between matching preprocessor directives, and on an override keyword to navigate to the base function

• Peek Definition view: Peek Implementations (Ctrl+Alt+middle button click or Control+Alt+Q) and Peek Base Symbols (Shift+Alt+Q) come to C++.

• File Structure now uses the C++17 syntax for nested namespaces.

• C++/CLI: Go to Derived Symbols now works for get/set functions inside C++/CLI properties and add/remove functions inside C++/CLI events.

• The bundled Clang-Tidy binary has been updated to Clang 11, adding new checks and compiler diagnostics.

• Support for /external:* compiler switches

• Updates to Catch2 support

• Faster Find Usages and Rename for private class members

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:

  • When looking for derived symbols in C++/CLI code, ReSharper C++ now finds symbols in C# code.

  • Go to Base Symbols and Go to Derived Symbols now work on imported CLR entities.

• 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

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+/ 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

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 add 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).

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 window

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.

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

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

Learn 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

C# 7.3 support, including declaration expressions in initializers and queries, tuple equality, ref assignments, array initializers in stackalloc, pattern-based 'fixed' statement, indexing movable fixed buffers; unmanaged, System.Delegate, and System.Enum constraints.

Integrated spell-checking engine.

Redesigned UX for most of refactorings.

An option to enable BeforeBuild/AfterBuild targets and pre-build/post-build events for projects skipped by ReSharper Build.

Initial support for Blazor.

You can specify ignored file masks on the Environment | Search & Navigation | General page of ReSharper options Alt+R, O.

Search Everywhere can now successfully parse function signatures copied and pasted from dotTrace or Visual Studio’s Call Stack window for further searching.

Formatter improvements: option to not indent inside namespaces, options for enum arrangements, "Max elements on single line" option for method signatures, method invocations and initializers

Ability to generate formatter-settings comments from the Configure formatting dialog.

Settings affected by StyleCop rules are shown in the File Formatting Info window.

Integration with JSlint, ESLint, and TSLint improves design-time validation of JavaScript and TypeScript code in the editor.

Separate built-in type reference styles for member access and for locals, members, and parameters.

New features for ReSharper C++ 2018.2:

• Initial C++/CLI support

• Improved C++17 including fold expressions, auto non-type template parameters, pack expansions in using declarations, using declarations with multiple declarators, guaranteed copy elision, class template argument deduction, aggregates with base classes, std::is_aggregate type trait, __has_include in preprocessor conditionals

• Initial support of the upcoming C++20 including Coroutines, Designated initialization, Feature test macros, Default member initializers for bit-fields

• Size and alignment calculations take into account bit-field sizes, alignas specifiers, and __decltype(align) attributes.

• Improved syntax highlighting — new color settings for static class fields and member functions.

• Code inspections for formatting rules.

• Expected failures specification is supported in Boost.Test unit tests.

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.

Debugging assistance features in C#, VB.NET, and C++: inline values, searchable DataTips, and breakpoints navigation.

Performance Guide (ReSharper | Options | Environment | Performance Guide) — an options page that helps you check and quickly fix ReSharper and Visual Studio preferences that affect performance

New formatter features:

• Enable/disable formatter or change formatter settings with comments or from EditorConfig files.

• Ability to reformat code with different line break styles (wrap or chop long lines, compactly reformat selection, etc.)

• An option to align similar code in columns.

• Options to insert blank line before or after complex statements; outdent binary operators, dots and commas; choose nested ternary expression style; and much more.

Generate Deconstructor actions and navigation features for C# 7 tuples.

Improved Extract Method refactoring can now extract local functions, return value tuple in the extracted method, work with expression-bodied members, and more.

New typing assists: multi-line block comments on Enter, chained method calls in C#.

Improved to-do items can now link to external URLs.

Ability to hide entries from the call tracking results.

The built-in decompiler can load assemblies from local NuGet package cache and show assembly PDB contents in a readable XML file.

New features for ReSharper C++ 2017.3 (an extended version is also available in a dedicated blog post):

• Nearly a thousand of new Clang code inspections: 611 Clang Diagnostics, 78 Clang Static Analyzer Checks, and 202 Clang-Tidy Checks.

• New quick-fixes and context actions.

• Code analysis: deduction of return type for auto functions and lambdas, improved support for explicit template instantiations, support for native C++ event handling MS extension.

• C++17 features support: structured binding declarations, inline variables, constexpr lambdas.

• Catch2 support (the new version of the Catch unit testing framework)

Support for .NET Core 2.0 projects in Visual Studio 2017 15.3.

Go to text is integrated into Search Everywhere.

Commands that navigate by name can handle incorrect word order inside a CamelCased identifiers as well as misspellings. They also support exact match queries inside quotation marks.

C# 7.1 support: inferred value tuple component names, default literals, async Main.

Go to File Nearby — a new navigation command.

New typing-assist features: add NotNull/CanBeNull annotations and convert expression-bodied to block-bodied members.

A new option to make properties mutable when implementing an interface with get-only properties.

A new option to make parameters optional when generating type constructors.

New options page (Code Editing | C# | Null Checking) that lets you customize generating null-checking routines for exceptions and assertions.

Debug modules that have no debug information (PDB).

XML is supported in language injections.

More context actions and quick-fixes supporting <inheritdoc/>.

Quick Documentation Control+Q as well as completion for scoped NPM packages are now available in project configuration files (project.json, package.json, and bower.json).

Improvements of the built-in decompiler: ability to retrieve assembly's original source code, which is referenced in the Portable PDB using Source Link; if any of the navigation and search commands results in multiple matches inside a single method, ReSharper now displays all of them in the search results .

Interactive tutorials (ReSharper | Help | Tutorials) to help you get started with ReSharper’s functionality or get up to speed with features in new releases.

Improved TypeScript/JavaScript support including:

• Finalized support for TypeScript 2.3 features: async iterators, optional generics, overload resolution for stateless JSX components, contextual this for object literals, and the --strict option.

• Full support for TypeScript 2.4 features: enums with string values (or mixed string/number values), generic inference from contextual type returns, and generic contextual signatures.

• Introduce/Inline Type Alias refactorings.

• Support for angular input/output aliases and attribute directives, for Angular2 components added via NPM, and improved support of Angular 4 syntax.

• Improved support for mapped type members in Find Usages and in the Rename refactoring.

New features for ReSharper C++ 2017.2 (an extended version is also available in a dedicated blog post):

• Ability to detect and fix violations of naming rules.

• An option to hide free functions in code completion.

• Support for extended friend declarations from C++11.

• Support for selection statements with initializer from C++17.

• SFINAE support for expressions.

• Clang-Format support.

Full support of Visual Studio 2017.

Filters in Search Everywhere and Go to text, which you can type right into the search field before or after the search query.

A new option that helps improve performance on large solutions by completely ignoring selected projects, configurable on the Code Inspection | Ignored Code page of ReSharper options Alt+R, O.

Find Results window improvements: grouping by the kind of usage (for both C# and C++), improved filters, possibility to search by exact match using quotes, error highlighting in found usages.

An option to open each new file you navigate to in the Preview tab, configurable on the Environment | Search & Navigation | General page of ReSharper options Alt+R, O.

EditorConfig support.

Contextual configuration of formatting rules is now available in C#.

Auto-formatting pasted code with ReSharper formatting preferences.

Tabs and indents in all supported languages can be now configured and stored in ReSharper's layered settings.

Other formatter improvements: Auto-detecting indents when reformatting code, support for comma-first style, options for the line breaks in a single case statement in C#, option to add line feed at the end of the HTML, CSS, or XML files.

Code styles for bodies of simple type members.

Context menu on a status indicator, which provides a quick access to a number of options and commands of code inspection.

Reworked UX of Code cleanup, which now lets you create and edit custom cleanup profiles right in the Code Cleanup dialog.

Unit testing assistance in .csproj-based projects in Visual Studio 2017 (requires Visual Studio 2017 update of March 28th or later).

Support for the routing attributes in Razor tag helpers: code completion, navigation & search commands, Rename refactoring.

Improved TypeScript/JavaScript support including:

• Full support of TypeScript 2.1 and 2.2, including mapped and indexed types, object rest and spread properties, configuration inheritance, untyped imports, combined types normalization, partially annotated signatures, and control flow analysis for implicit any and implicit any arrays.

• Experimental support of Angular 2 HTML template language.

• Navigate To: Function Exits and Navigate To: Implementing Members.

• Generate Properties for TypeScript classes.

• Postfix templates.

New features for ReSharper C++ 2017.1 (an extended version is also available in a dedicated blog post):

• About 30% decrease in managed memory usage when a solution is loaded from cache.

• The set of C++ postfix templates is extended with beg..end, new, var, const_cast, dynamic_cast, reinterpret_cast, static_cast, make_shared, and make_unique.

• Formatter improvements: Indenting for the preprocessor directives, space after parentheses in cast expressions, break line in simple case statement, indenting for namespace members.

• File header style.

• New code cleanup tasks for removing code redundancies.

• New options page for configuring C++ tests (Tools | Unit Testing | Test Frameworks | C++ Tests).

• Initial support for Open Folder and CMake projects.

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 popups 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:

• TypeScript 2.0.2 ("2.0 RC"): boolean, number and enum literal types.

• Go to Implementation in TypeScript.

• Encapsulate Field refactoring in TypeScript.

• 'Surround with type guard' quick fix

• Structural navigation with Tab and Shift+Tab in JavaScript and TypeScript.

• Performance improvements.

New features for ReSharper C++ 2016.3:

• Postfix completion and postfix templates.

• Introduce typedef and Inline typedef refactorings.

• Unit testing assistance is now available for C++ test framework, Catch and Boost 1.62. Unit tests are also automatically updated for externally changed files.

• C++ code analysis in the InspectCode Command-Line Tool.

• Syntax highlighted tooltips for C++ code elements. The tooltips display method and field signatures, as well as formatted Doxygen and C#-style XML comments.

• Support for nested namespace definitions introduced in C++17.

• New options for C++ formatter: 'Spaces within parentheses in cast expressions' and 'Place enumerators on new line'.

• Properties get read from Linux Makefile projects

• Memory usage optimizations.

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

Go to Text.

Structural navigation with Tab and Shift+Tab.

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 window improvements: when you place the caret at 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 popups can display documentation from documentation comments optimized for Doxygen.

Invert Boolean refactoring that helps you quickly modify boolean members so that they get the opposite meaning.

Smart Paste that helps you automatically escape illegal characters in text that you copy/paste around your code.

Two new code style features for: braces around single-line statements and using named/positional arguments.

A dedicated command that reformats code in the selected scope - Control+Alt+L ( ReSharper | Edit | Reformat Code). Previously, you could do the same by invoking code cleanup with the 'Built-in: Reformat code' profile.

A dedicated command that applies code style in the selected scope - Control+Alt+S ( ReSharper | Edit | Apply Syntax Style). Previously, you could do the same by invoking code cleanup with a custom profile that enables code style tasks.

Optimize References and Remove Unused References features can correctly handle NuGet references.

Ability to change preference of displaying parameter information tooltip above or below the caret.

Ability to attach the debugger to an executing run configuration.

Ability to view intermediate language (IL) side by side with your source or decompiled C# code.

Out-of-the-box unit testing assistance for xUnit.net.

Pasting items from clipboard history can be now done without opening a modal dialog.

Support for new language features in VB 14

Initial support for JSON files and schemas

Initial support for Node.js.

Improved TypeScript/JavaScript support including:

• New formatting settings that allow you to define line breaks and wrapping in a more granular way.

• Initial support for experimental JavaScript syntax constructs that are projected to be part of ECMAScript 7 (comprehensions, decorators, class properties, exponentiation operator, rest and spread properties for object literals).

New TypeScript specific features:

• Full support for TypeScript 1.7 features.

• Full support for TypeScript 1.8 including string literal types.

• Resolving types behind var, let, and const keywords.

• Rename refactoring can now rename files corresponding to TypeScript types.

New features for ReSharper C++ 2016.1:

• Support for To-do items in C++ files.

• The Rename refactoring can now rename C++ files.

• The list of supported C++ language features is extended with generalized lambda captures (C++14), exception specifications, user defined literals and delegating constructors.

• Support for the Boost.Test framework in the unit test runner. Note that (as of ReSharper Ultimate 2016.1.1) only Boost versions 1.59 and 1.60 are supported.

• Code generation improvements: The Generate stream operations action can now generate stubs for Boost Serialization functions: save(), load() and serialize(). Also, formatting options are now taken into account when generating code.

• All ReSharper C++ actions are now banned from changing library headers.

Postfix templates and other new items in completion lists will help you transform expressions you have already typed without jumping backwards.

Ability to build your solution incrementally using multiple parallel processes with ReSharper Build.

Ability to change code style preferences right from the editor.

Code styles for optional parentheses to help you get rid of redundant parentheses and/or automatically add parentheses to clarify operation precedence.

Usage-aware behavior of the Go to Declaration command (Control+B or Ctrl-click).

Updated Stack Trace Explorer window shows types as clickable hyperlinks, allows wrapping long lines, and parses more types of data, including WinDbg GCRoot dumps and Visual Studio’s Call Stack tool window contents.

Support for Google Protocol Buffers (Protobuf).

Improvements in JavaScript support: JSX in .jsx and .js files, regular expressions assistance in plain strings and related methods, coding assistance features for JSDoc types.

Full support for TypeScript 1.6, including intersection types, union types, and TSX files.

Support for NUnit 3.0 Beta 4.

New features for ReSharper C++ 10.0

• Full support of C99 Standard Library, including code inspection, quick-fixes, and more.

• C++ support improvements including char16_t and char32_t builtin types, compile-time expressions of floating point types.

• Generate Google Mock methods action.

• Reduced time to get ready to work (for already cached solutions).

Full support of Visual Studio 2015.

Run configurations that help you run and debug code in your solution with different startup properties.

Massive improvements in JavaScript and TypeScript support:

• Support for Typescript 1.5 (including decorators, ES6-compatible modules, ES6-style imports/exports, local types)

• Support for some of TypeScript 1.6 features (for example, generators, type predicates, generic type aliases, abstract classes, async function-like entities, await expressions)

• Go to Type of Symbol in TypeScript

• Regular expressions assistance in JavaScript and TypeScript.

• Import Symbol Completion Control+Alt+Space for TypeScript.

• File Templates for TypeScript.

New features for ReSharper C++ 1.1

• Unit testing assistance for Google C++ Testing Framework

• Introduce Namespace Alias refactoring.

• Hierarchy of includes.

• Go to Type of Symbol.

Improvements in Visual Studio 2015 CTP support

.NET framework 4.6 support

TypeScript 1.4 support

ECMAScript 6 support

Improvements in the Find Usages feature, including support of 'quasi-implementation' feature of C# and selection of the search algorithm for generic substitutions.

Source templates that can be created right in the code of your project as extension methods.

NuGet Browser that halps you search for types or namespaces in the NuGet package gallery and easily download and install the package that you choose.

Configurable style for usages of built-in type.

Installer improvements: silent and per-machine installation modes.

JSDoc support in JavaScript and TypeScript.

Ability to match dependency properties and arrange items in groups as well as other improvements in file and type layout.

New commands for copying symbol information n (XML-doc ID and fully-qualified name) to the clipboard

Visual Studio 2015 CTP support

C# 6.0 support, including conditional access expression, expression-bodied members, auto-properties with initializer expression,

etc.

Support of C++ in the dedicated product ReSharper C++, which is also available as a part of ReSharper Ultimate.

Regular expressions assistance including syntax and error highlighting, completion features, quick-fixes and more.

Type dependency diagram - a new visual code analysis tool that complements the existing project dependency diagram.

Major improvements in TypeScript support, including, but not limited to:

• Configurable TypeScript language level up to 1.3.

• New code inspections including inspections for about 300 compiler errors and inspections dependent on project properties + about 100 new quick-fixes. For more information, refer to Code Inspection and Quick-Fixes in TypeScript.

• Import missing namespace popup.

• Code generation actions (Generate missing/overriding members, Generate constructor).

Performance improvements and new features in code completion. You can now apply filters to completion suggestions, complete call chains based on existing patterns in your solution, and more.

Code style assistance improvements: a number of new code style preferences that have common configurations for both code inspection and code cleanup. For more information, refer to Code style and cleanup.

Entering license information using the JetBrains Account.

Ability to suppress some or all code inspections in specific type or method using the SuppressMessage attribute.

The Fix in scope feature is supported for more quick-fixes. Now the global fixes work for naming rules, code redundancies, and more.

Similarly to 'Fix in scope', some context actions can also be applied in a wider scope.

The Navigate to Action feature that allows you to find and execute any ReSharper command with a couple of keystrokes.

The Navigate To: Exposing APIs action that allows finding all methods returning a specific type.

Recently viewed methods and performance improvements in Search Everywhere.

A new visual editor greatly simplifies understanding and editing of file and type layout patterns.

Support of custom HTML harness for JavaScript unit tests.

Search through preferences in the ReSharper options dialog.

Ability to toggle support of languages and feature sets on the Environment | Products & Feature page of ReSharper options.

Ability to view and configure code formatting rules that are applied for selected code block (supported in JavaScript, TypeScript, and C++).

Bug fixes and performance improvements

Improvements in TypeScript support

• More quick-fixes and context actions

• More navigation options

Jasmine 2.0 support for unit test runner

Support for Visual Studio 2013

Enhanced support for Peek Definition

Marker bar and scroll bar integration in Visual Studio 2013

JavaScript navigation improvements

TypeScript support

Support for Visual Studio 2013 Preview

Extended code completion capabilities:

• Double completion

• Generative completion

More navigation options:

• Search everywhere

• Navigate to generic substitutions

• Navigate To: Assembly Explorer

Easy plugin discovery and installation via Extension Manager

New refactorings:

• Inline Parameter refactoring

• Move Instance Method refactoring

A call diagram (Push/Pull parameter tool) for adding new argument to method calls in the Change Signature refactoring.

Assembly Explorer

A new possibility to explore dependencies between projects via Architecture View

Multi-file templates

Quick-fixes for larger scopes

Improvements in XAML support

The Extract Class refactoring is now available for VB.NET

Support for named arguments in the Change Signature refactoring

Completion for enum members in VB.NET

A different treatment of Preview Tab

Improvements in XAML support

Quick unit test search in the Unit Test Sessions window and Unit Test Explorer window.

Support for Caller Info attributes

Code formatting for XML doc comments

Flexible formatting settings for alignment with tabs

Sharing options for code inspection results

Support for Visual Studio 2012:

• Support for color themes

• Asynchronous solution loading

• Support for Metro-style application development and WinRT

• Support for the Preview Tab in navigation and search features

Custom contract annotation attribute

More options to control code completion behavior

JavaScript improvements

Unit Testing improvements:

• Support for NUnit 2.6 and MSTest 11

• Support for Jasmine and PhantomJS

Naming style improvements

Member hierarchy

CSS style hierarchy

New code inspections and quick-fixes.

Quick-fix groups

Transform Out Parameters refactoring

New code generation features: Generate partial methods and Generate equality comparer.

Removing unused references from entire solution

Async CTP Support for C# and VB.NET

Optimizing references and removing unused ones

Safe delete assembly references

Path mapping for Web projects

Improved Type Hierarchy

Settings sharing and management

New interface of the Templates Explorer window and improved templates sharing

Localization assistance for VB.NET and ASP.NET MVC 3 (Razor)

Improvements for web developers:

• JavaScript support

• CSS support

• ASP.NET MVC 3 Razor view engine support similar to the previously introduced ASP.NET MVC ASPX view engine support

• Basic HTML support

Code analysis in VB.NET

Bundled decompiler

Extended navigation and search

• Navigation to Extension Methods

• Navigation to Parameter Declaration

• Support for paths and FQNs in Go to Symbol, Go to File, and Go to Type

Color Assistance

Improvements and bug fixes in XAML support

Finding similar issues

Inplace refactorings

New features in ReSharper Unit Test Runner and JavaScript Unit Testing support for QUnit

An extensive feature pack for web development:

• Master page support in navigation and generation actions.

• Generating Content tags based on ContentPlaceHolder tags in master pages.

• File Structure and Go to File Member in ASP.NET markup files.

• Go to Related Files

• Navigation, search and auto-import features for user controls

• Live, surround, and file templates for ASP.NET pages, including master pages

• ASP.NET MVC support pack including:

  • Special syntax highlighting, including highlighting for unknown items.

  • Dedicated code completion.

  • Navigation to and from actions or controllers.

  • Creating new actions and controllers from usage in pages.

Project maintenance and teamwork feature pack:

• Structural Search and Replace.

• Navigation to and within external sources.

• Project-level refactorings, including Move to Folder, Move Types to Matching Files, and Adjust Namespaces, and updated Safe Delete.

• Project Hierarchy view.

• Localization assistance.

Support for Visual Studio 2010, including C# 4 and VB10.

Code analysis enhancements:

• Call Tracking.

• Value Tracking.

• Code inspections and quick-fixes to upgrade from loops to LINQ.

• Code inspections and quick-fixes to use IEnumerable where possible.

• Inspection Results window.

• New and improved code inspections.

Other enhancements:

• Automatic completion for enum members.

• Completion for unresolved symbols in local scope.

• Code bookmarks.

• Native NUnit support.

• XML formatting.

Major performance and memory usage enhancements.

Support for VB9.

Extended naming style settings.

Solution-wide code inspections to discover unused non-private members.

Go to Implementation to navigate from usage of a base type or member to any of its end implementations.

Inline Field refactoring

Native MSTest support.

Support for Microsoft Visual Studio 2008 SP1.

ASP.NET enhancements.

Improved performance and usability.

Bug fixes.

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, Type-Matching 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.

Solution-wide error analysis.

Support for web-based License Server.

Bug fixes.

Comprehensive support for VB.NET: versatile coding 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.