What′s New in ReSharper C++

Performance improvements

ReSharper C++ 2019.1 introduces many performance improvements to speed up indexing and reduce memory usage. Both warm opening of large solutions and cold startup times have been improved. The memory usage optimizations include lower memory traffic during initial indexing, and a smaller memory footprint afterwards, which both help to enhance the editor responsiveness. Several performance improvements to code navigation and code completion are also inside.

In addition to memory optimizations, algorithmic improvements in code indexing, and faster cache serialization, we’ve added some special tuning for Unreal Engine projects. This includes skipping plugins and third-party code by default when indexing an Unreal Engine 4 project. The options that affect code indexing in Unreal Engine 4 solutions are grouped under a new options page at ReSharper | Options | Code Editing | C++ | Unreal Engine.

Unreal Engine support

Unreal Engine naming convention

Naming rules help keep code readable. It may come as no surprise then that Epic Games has published the Unreal Engine 4 coding style guide, with a large section dedicated to their naming convention. Their general recommendation is to follow this guide when developing games with Unreal Engine. ReSharper C++ 2019.1 accommodates this naming convention across all its actions, including Introduce Variable and Rename refactorings, code generation for getters and setters, and many others.

ReSharper C++ also keeps an eye on the names you use across your code base. It highlights any inconsistencies with the UE4 naming convention by running Inconsistent UE4 naming inspections. Apply the corresponding quick-fix to trigger a full Rename refactoring for such a symbol.

Completion for reflection specifiers

To help you easily work with Unreal Engine reflection macros, ReSharper C++ offers completion for reflection specifiers inside reflection macros:

Working with Remote Procedure Calls

ReSharper C++ 2019.1 will identify RPCs by Client, Server, or NetMulticast keywords in the UFUNCTION declaration statement. For such functions, ReSharper C++ is aware that an _Implementation function should be generated, as well as a _Validate function if WithValidation is set. It can generate both if both are missing, or only one if only one is missing.

When navigating to a definition, both functions (_Validate and _Implementation) will be suggested. Alternatively, these options are available in the Alt+Enter menu too, as “Related UE4 functions”. Learn more.

Auto-import respects the generated headers

When you use a symbol that’s not available in the current scope, ReSharper C++ highlights it in red and suggests adding the missing #include when possible. When the #include is missing from a header file, it will be inserted before the .generated.h, which should be the last one in the list of includes. The incorrectly placed #include is highlighted by the corresponding inspection.

In addition, auto-import no longer suggests symbols from Private and Classes folders of your UE4 project.

C++ language: C++17 and C++20

C++ understanding is enhanced further:

• From C++17, we’ve added support for hexadecimal floating-point literals.
• From C++20, basic support for Contracts and a three-way comparison operator was added, which includes accurate parsing and some partial resolve to get rid of obvious false-positives in the code.
• C++20’s familiar template syntax for generic lambdas was added.
• Alternative (text form) representation of operators is now supported.

K&R style C declarations

ReSharper C++ can now correctly handle C declarations in the K&R style. So if you have a legacy library using this kind of style or just prefer it for some reason, ReSharper C++ will now be able to work with it nicely:

Clang-Tidy

For a while now, ReSharper has provided seamless integration with Clang-Tidy, a powerful open-source code analysis tool based on the Clang compiler. In v2019.1, we’ve upgraded the built-in Clang-Tidy binary to Clang 8, to give you many new code checks and the accompanying fixes.

Clang-Tidy options are now grouped on a separate options page under Options | Code Editing | C++ | Clang-Tidy. You can list the checks you wish to enable/disable using a simple text form there, provide a Clang-Tidy config, and even provide a custom Clang-Tidy binary that will be used instead of the bundled one.

Navigation

To make the editor as responsive as possible, this release speeds up Search everywhere and Go to type. Go to file member, Go to base class, and Go to derived class searches are now available during indexing.

The performance of Go to Everything was also improved in several ways, including overall performance, search for patterns with :: or spaces, and other areas.

When calling Go to File Member, you can now include base members in the list and navigate to them as well.

Naming Convention

We’ve reworked the C++ Naming Convention settings page (ReSharper Options | Code Editing | C++ | Naming Style). Now you have two separate lists, specifiers and entity kinds (organized in a tree), and you can combine them and add rules specific to one or several kinds of entities.

Several new entity kinds were introduced to make the configuration even more flexible:

• Template parameters were split into type and non-type template parameters.
• Parameters were split into function and lambda parameters.
• Enumerators were split into scoped and unscoped enumerators.

Formatter

The formatter settings include many new options and enhancements:

• To make the formatter more flexible, we’ve separated the formatting options for spaces around references and pointers. There are now two sets of options for each case, so, for example, you can add a space before a reference in the return type of a function, but skip it before the pointer.
• You can wrap before the commas of a base class list.
• Lots of new ClangFormat options are supported in ReSharper C++, such as CompactNamespaces, AllowShortBlocksOnASingleLine and AllowShortFunctionsOnASingleLine, AccessModifierOffset, BreakBeforeBraces: Custom, and many others.
• In settings you can see now which formatting options are affected by a given ClangFormat options.

Documentation

When you are typing a documentation comment in your code, a typing assist will automatically insert /// on a new line when you press Enter. If there is an XML documentation comment for a function and its parameter is being renamed via the Rename refactoring, then the corresponding <param> tag in the documentation comment will also be updated. That is not all: if you rename the parameter manually, ReSharper C++ will highlight the mismatch for you and will suggest adding a new <param> tag or renaming the existing one.

Unit testing

In unit testing, the following are now supported:

• TEMPLATE_PRODUCT_TEST_CASE test declarations from Catch 2.7, and
• The GTEST_SKIP() macro from Google Test.

Additionally, we’ve increased the number of supported frameworks (previously we covered Google Test, Boost.Test, and Catch) and added support for doctest. This is a relatively new framework which is lightweight and very flexible. It allows tests to be written directly in the production code and at the same time offers a way to remove everything test-related from the binary.

Responsive editor

ReSharper C++ 2018.3 offers several notable performance improvements. First, Find code issues and InspectCode command line tool are now parallelized, which makes them significantly faster. Second, Cache loading on project reopening is now parallel as well, which makes it twice as fast on average. Finally, there are general performance improvements in code completion, initial project indexing, and file analysis.

Unreal Engine support

Start working with your Unreal Engine 4 projects in mere seconds! When opening a solution, ReSharper C++ only parses non-engine projects, while the engine files are indexed in the background later. This means you can start typing or navigating through your project seconds after you open it!

Unreal Engine uses specific macros (UCLASS, USTRUCT, UENUM, etc.) to emulate missing reflection features in C++. These macros are now parsed by ReSharper C++ correctly, even before you build your Unreal Engine project.

Improved C++/CLI support Ultimate

Support for C++/CLI is enhanced in v2018.3, offering lots of smart ways to generate missing C++/CLI code:

• Generate actions to generate .NET Equals() and GetHashCode()
• Generate constructor and Generate getter/setter, which generates C++/CLI properties
• On C++/CLI classes, you can also call Create derived class/struct/interface
• Code completion works after objects of generic types in C++/CLI. Smart type completion, which filters the list of types, methods, and variables to match the expected type, now work after gcnew
• New postfix templates, new and foreach, in C++/CLI code
• You can also create a field and member function from the actual usage for C++/CLI classes

Better error diagnostics in templated code

When the overload resolution fails in C++, ReSharper C++ 2018.3 now provides a more specific description of the cause, identifying the exact requirements that aren’t satisfied. This is especially helpful for failed enable_if conditions, ill-formed expressions inside decltype, and absent inner types.

Learn more

Code completion in dependent code

If that wasn't enough, completion now uses default template arguments to provide suggestions in dependent code.

Hints and parameter info

The Parameter Info popup shows even more information such as deleted functions, implicitly generated functions, and template parameter descriptions taken from documentation comments for template arguments. Parameter Info also works for dependent code and for user-defined binary operators. To finish things off, it’s now colored and more readable.

C++ name hints in function calls and aggregate initialization can help you find your way through long (and sometimes nested) lists of parameters. You may also find useful the new name hints at the end of namespace definitions, right after the closing brace.

Code inspections and quick-fixes

More than 10 new inspections were added, many of them with matching quick-fixes to resolve the detected problems. For example, now there's a quick-fix you can use to add a functional-style cast and initialize all uninitialized members/bases. Meanwhile, integration with Clang-tidy was updated to Clang 7, bringing 50+ additional checks.

Refactorings and code tweaks

ReSharper's refactorings are now more knowledgeable about modern C++. When you use the Change Signature refactoring, you can now choose to make a function constexpr, const, or noexcept, as well as change the ref-qualifiers.

ReSharper C++ 2018.3 also introduced several new context actions to help improve your code base:

• Generate a function implementation and copy it to the clipboard instead of inserting it into the document.
• Generate a function that converts an enum to a string (customizable via a live template).
• Convert a regular return type in a function declaration into a trailing return type, and vice versa.
• Insert template arguments deduced using class template argument deduction.

Navigation

Go to declaration now works on non-dependent decltype specifiers and lambdas (going to the lambda body). It even works during the initial project indexing, saving you even more time!

Search Everywhere, a universal search action, has added some additional filters. For example, /gf for global C++ functions, /gv for global C++ variables, or /d for macro definitions.

The handiest feature, however, has to be navigating to unmatched signatures. For example, when Go to declaration is called on a changed declaration of a member function, it goes to its definition with an old signature.

Code Style

Often it's much easier to customize formatting settings by simply detecting them from the existing code. This is now possible! Use ReSharper | Edit | Detect formatting settings menu to have ReSharper detect code formatting settings. You'll get the tool window with the detected values, which can be reviewed and applied to the ReSharper settings on your machine. Or, you can save them to a team-shared settings layer so that other developers on your team will have the same code formatting configuration when opening the current solution. Learn more

ReSharper C++ can't auto-detect C++ naming schemes for now, but predefined C++ naming styles were added to the settings: STL, Google, LLVM, CamelCase, and Microsoft. Select it in ReSharper Options | Code Editing | C++ | Naming Style.

Unit testing with Catch

This release also provides support for Catch 2.5 and its new templated tests.

Initial C++/CLI support Ultimate

C++/CLI is a set of C++ language extensions by Microsoft for easy interoperability between managed and native code. With extensive support for both managed languages and C++, it is only natural for ReSharper to offer help with writing code in C++/CLI too.

However, with so many syntactic additions and peculiar changes to the C++ language semantics, handling C++/CLI is no easy task. But now the wait is over — ReSharper C++ 2018.2 makes C++/CLI support public, with many major features (including code inspections, typing assistance, formatting, and code completion) updated to support this language dialect.

Please remember that we are still working on improving C++/CLI support, and cross-language navigation and refactorings are a work in progress. As we move to expand our coverage we would love to hear your feedback on what is missing and what you feel we should concentrate on.

C++/CLI support requires a ReSharper Ultimate subscription and the ReSharper product to be enabled. To learn more, see C++/CLI support comes to ReSharper C++.

C++17 features

Another area that we’ve been putting a lot of effort into is our ongoing work on support for C++17. ReSharper C++ 2018.2 adds understanding of the following new features:

• Class template argument deduction and user-defined deduction guides.
• Fold expressions.
• Auto non-type template parameters.
• Pack expansions in using declarations.
• Using declarations with multiple declarators.
• Guaranteed copy elision.
• Aggregates with base classes.
• std::is_aggregate type trait support.
• __has_include preprocessor macro.

All in all, these updates mean that most of the major C++17 features are now supported by ReSharper C++, with the two biggest omissions being hexadecimal floating point literals and noexcept as a part of the function type.

C++20 features

The C++20 standard is already shaping up and its features are becoming available in major compilers. Keeping up with the evolution of the language, ReSharper C++ now supports several features from the upcoming standard:

• Coroutines (as specified in the n4760 Coroutines TS draft).
• Designated initialization.
• Range-based for statements with initializer.
• Feature test macros.
• Default member initializers for bit-fields

Integrated spell checking with ReSpeller

ReSharper C++ 2018.2 provides spell-checking functionality out of the box, thanks to the newly bundled ReSpeller extension which has also been updated to support the C++ language. Just like with code analysis, ReSpeller scans for spelling mistakes and typos in identifiers, comments, and string literals, and provides quick-fixes to resolve these problems.

When you encounter a spelling mistake, you can invoke the Alt+Enter menu and ReSpeller will provide several options to fix the problem: we can either fix the typo or add this word to ReSpeller's dictionary. By default, the spell checker comes with a built-in dictionary for English (United States), but dictionaries for other languages can be easily added too.

For instructions on adding a new dictionary and more info about ReSpeller, see Integrated spell checking with ReSpeller in ReSharper and Rider.

Formatting inspections

Every now and then, you want to be notified directly in the code when you are not following formatting rules. With this in mind, ReSharper's code formatting engine introduces inspections and quick-fixes for formatter-related problems: inconsistent indenting, line breaks, spaces, and blank lines can now be observed and fixed directly in the code editor.

By default, formatting inspections are disabled so as not to bother anyone who doesn't care about formatting during typing. Go to ReSharper | Options | Code Inspection | Inspection Severity | C++ | Formatting to see all the available inspections and select severity levels for those of them that you wish to be notified of.

To learn more, see Maintaining consistent code style with formatting inspections.

Other changes

As usual, ReSharper C++ 2018.2 comes with many smaller improvements in different areas:

• When performing size and alignment calculations, the code analysis engine takes into account bit-field sizes, alignas specifiers, and __decltype(align) attributes.
• Parameter Info provides details about members of the aggregate class when performing aggregate initialization.
• Comments in a code file to override formatter settings can be generated directly from the Configure Format dialog.
• Range-based for statements provide references over the colon for easy navigation to the begin() and end() functions used by the loop.
• Separate color settings for static class fields and static member functions were added.
• Expected failures specification is supported in Boost.Test unit tests.
• A lot of performance fixes in different areas of ReSharper were made, from speeding up ClangFormat support to decreasing solution loading time. More detailed information is available in the performance blog post series dedicated to the ReSharper 2018.2 release.

Debug Step Filters

Step Filters is the latest addition to the host of features provided by ReSharper C++ for debugging. When you invoke Step Into, the Visual Studio debugger will normally step into all the functions that are called from the current statement. However, some of the functions are either trivial or so well tested, that you don’t want to step into them. This is where Step Filters comes in: with this feature you can specify functions that should always be stepped over by the debugger.

ReSharper C++ comes with a predefined collection of step filters for the standard library, but you can always add new ones:

• You can inspect, configure, disable or enable back step filters on the Tools | Debugging | C++ options page, which has a list of all the available step filters.
• When you step into a function and decide that you want to step over it in the future, you can use a context action to quickly add this function to the list of step filters. For template functions, there are separate context actions to add either only the current instantiation of the function or all its instantiations.

To learn more, see Step Filters in ReSharper C++.

Includes Analyzer

Compilation times are one of the biggest problems in large real-world C++ projects. ReSharper C++ 2018.1 introduces the Includes Analyzer, a new code inspection tool which helps you gauge which header files in your project contribute the most in terms of lines of code to the total compilation workload. To use it, invoke one of the ReSharper | Inspect | Analyze Includes in … actions or select Analyze Includes from the context menu in the Solution Explorer. ReSharper C++ will analyze the files in the given scope and give a report in a dedicated tool window.

The report lists files sorted by the number of lines of code they contribute together with their transitively included files. You can then dig into dependencies between the files either with the Includees tree view where child nodes correspond to the files that include the file in the parent node, or the Includers tree view where child nodes are the included files. Using these two views, you should be able to pinpoint the header files that contribute the most and then try to get rid of any unnecessary #include directives.

Navigation improvements

The Go to File Member dialog has been redesigned. Class members are now grouped by their containing class in the results list. Moreover, with no search, active file members are sorted in the order of their declarations, and the scrolling list with the results accommodates more items. Together these changes improve the usability of the dialog by providing clearer insight into the structure of the current file.

In all Go to dialogs and several other places ReSharper C++ now attempts to shorten symbol names that are excessively long by cutting out the function and template parameters.

When you perform a search using the Recent Files dialog, Go to File search results are also appended to the results list after the Recent File items.

Finally, the option to remember the last search in the Search Everywhere dialog is now on by default. You can revert to the old behavior through the Environment | Search & Navigation | Remember last search setting.

Command-line code cleanup

ReSharper Command Line Tools, a free standalone collection of tools that can be used from the command line or as a part of the continuous integration process, now lets you perform code cleanup in C++ projects. Run cleanupcode.x86.exe on your solution, and it will automatically reformat your code, remove common redundancies, apply Clang-Tidy fix-its and common code style fixes. This instantly eliminates code style violations in a project or a solution, and ensures a uniform code base.

In related news, bogus errors which were output by the InspectCode tool on x64 projects were fixed in this release. In addition, TeamCity 2018.1 is able to run InspectCode on C++ projects (see TW-48978 for details).

To learn more, see Code Cleanup with the ReSharper Command Line Tools.

Code inspections

ReSharper C++ adds the following new built-in inspections:

• New inspection (with a corresponding fix and a code cleanup item) that suggests replacing if statements with if constexpr statements when the condition is a compile-time constant expression.
• A set of inspections to diagnose usages of deleted functions.
• Control flow and usage checking inspections have been updated to work inside lambda bodies.

More ways to configure inspection severities

In ReSharper С++ 2018.1, .editorconfig files can now be used to set inspection severities for any scope: the entire solution, a project, or even a specific file. Besides this, inspection severity settings can be read from the project’s DotSettings file. It means that different projects can have different sets of enabled/disabled inspections or different inspection severities.

Check the Read settings from EditorConfig and project settings option on the Code Inspection | Settings | General options page to enable this feature.

To learn more, see Configuring inspection severities with EditorConfig.

Clang-Tidy integration updates

Clang-Tidy integration has received a few enhancements:

• Bundled Clang-Tidy has been updated to version 6.0, which brings several new checks.
• A new inspection action lets you disable a specific Clang-Tidy check in the current line by its name.
• When the Clang-Tidy executable crashes, no system error dialogs will be shown from now on.

Other improvements

Other changes to ReSharper C++ include the following:

• 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, it will show various information about the selected expression, such as its type, value, and value category.
• The new Tools | Unit Testing | C++ Tests | Use command-line arguments … setting controls whether ReSharper C++ should use the value of the Debugging | Local Windows Debugger | Command Arguments project property when running unit tests.
• Performance of the completion pop-up has been improved.

Debugger features

ReSharper С++ 2017.3 brings the debugger into the editor: local variables, function parameters, current line expressions and function return values are now displayed inline right next to the corresponding code. In addition, ReSharper C++ comes with the new Go to Breakpoint action (Ctrl+Alt+F9) and the R# Breakpoints tool window for quick navigation between breakpoints in the solution, as well as the ability to create breakpoints and tracepoints from the Find Results tool window.

ReSharper C++ also provides its own debugger DataTips with the ability to search inside them for a specific value. To access ReSharper DataTips, click the inline value display or replace Visual Studio DataTips in the Tools | Debugger ReSharper options page.

Clang-Tidy integration

Clang-Tidy is a powerful open-source code analysis tool, based on the popular clang compiler. It comes with the extensive set of code checks and accompanying fixes. ReSharper C++ 2017.3 provides seamless integration with Clang-Tidy, meaning that it simply works in the background as you edit your code, with inspection results shown on-the-fly in the code editor along with built-in inspections. ReSharper C++ also lets you apply the fixes provided by Clang-Tidy individually, as scope actions, or from Code Cleanup.

In addition to the diagnostics from Clang-Tidy checks, Clang-Tidy also issues diagnostics from the Clang Static Analyzer and warnings provided by the clang compiler itself. All of them have corresponding ReSharper inspections with configurable severity levels, which can be tuned according to your needs.

Please note that files using UTF-16 or UTF-32 encoding are not supported by Clang-Tidy at the moment.

Language understanding

Improving C++ understanding was a major focus of the 2017.3 release, with several C++17 and C++14 features now supported:

• C++17 structured binding declarations.
• C++17 inline variables.
• C++17 constexpr if statements.
• Deduction of return type for auto functions without trailing return type from C++14.
• Type checking and return type deduction for lambda expressions, including support for C++14 generic lambdas.

The rest of the language-related changes include:

• Support for include_alias pragma directives.
• Improved handling of explicit template instantiations.
• Support for the event handling Microsoft C++ extension.

Code inspections and context actions

ReSharper C++ 2017.3 comes with a set of new code inspections with accompanying fixes:

• Binary operator with identical or equal arguments.
• Redefinition of a default function argument from another declaration or a base function.
• Redundant const specifier on a parameter in a function declaration.
• Missing function parameter description in a documentation comment.
• Redundant member initializer in a member initializer list.
• Non-inline variable definition in a header file.
• User-defined literal suffix that does not start with an underscore.
• Detailed diagnostics about errors in structured binding declarations.

A couple of new context actions were also added:

• Convert a member initializer in a member initializer list into a non-static data member initializer.
• Switch between class and typename keywords in a type template parameter declaration.

Code formatting

Formatter can now be enabled/disabled from comments and configured using inline EditorConfig-style settings. It also adds a number of new options for more flexible formatting, including options that control:

• Multiline code formatting:
• Aligning code in columns for assignments, declarations, and single-line comments.
• Outdenting commas and member access operators in chained method calls.
• Spaces before/after commas in uniform initialization braces and before end of line comments.

Go to Declaration improvements

The Go to Declaration command is now available on dependent names inside definitions of templates. Since ReSharper C++ has no means to find the exact entity that the name refers to, instead all symbols with matching names and signatures will be found and offered as potential navigation targets.

Furthermore, Go to Declaration now lets you navigate from a function definition to a declaration with a non-matching signature, if no matching declarations are found.

Performance Guide

ReSharper Performance Guide collects a set of Visual Studio and ReSharper settings that might affect overall performance in one place and provides a way to quickly change them. The Performance Guide page can be found in ReSharper options, under Environment | Performance Guide.

Other changes

• Catch2, the latest version of the popular Catch unit testing framework, is supported.
• To-do items support linking to external resources.
• Redesigned preview pane in ReSharper tool windows and formatter options pages.
• Find Usages window supports multi-line occurrences.
• Search Everywhere always shows text matches, even when there are other results.

C++11 and C++17 features

ReSharper C++ 2017.2 understands C++11 extended friend declarations and finalizes support for string and floating-point user-defined literals. The ongoing work on C++17 support is also progressing: selection statements with initializer, using in attribute namespaces, and capturing *this by value are all supported now. In addition, code inspections now take C++17 [[nodiscard]] and [[maybe_unused]] attributes into account.

Code formatting

The code formatting engine receives two major enhancements:

• ClangFormat configuration files are supported and get automatically used as a source of formatting style settings.
• Long lines can be optionally wrapped, with a number of new settings for the wrapping behavior.

A number of new formatting options were added, in particular options that control:

• Line breaks after template headers and function return types;
• Indentation of parentheses in function declarations, method calls and if/while/for statements.

Code inspections and quick-fixes

ReSharper C++ 2017.2 adds several new code inspections:

• Inconsistent Naming detects violations of naming rules in your code. Additionally, the Naming Style options page was updated to allow adding custom naming rules, which let you configure this inspection.
• Local variable may be const highlights local variables that can be made immutable.
• Unused entity inspections extend their scope from local variables and function parameters to also include global variables/classes/enums that have internal linkage or are members of an anonymous namespace.

A number of new quick-fixes for existing inspections were also introduced, including Add std::move when cannot bind rvalue reference to lvalue, Return unused expression, and Add an #ifndef/#define/#endif include guard.

Navigation improvements

• Navigate to file nearby displays project structure around the current file.
• Go to Text is integrated into Search Everywhere.
• Go to Everything searches now return results even when word order inside a CamelCased identifier is incorrect.
• Exact search supports adding quotes and using wildcards inside quotes to enforce a more precise match.