ReSharper C++ 2019.2 includes dozens of code completion, navigation, and code analysis enhancements. This is accompanied by a completely new preprocessor engine now used at the indexing stages, which can deliver 15-25% faster indexing on typical solutions. To keep up and on track with the modern language changes, more C++20 features are supported in this version. And for Unreal Engine 4 projects, there’s more sophisticated support for RPC and reflection macros.
In this release, we have finalized what we have been working on over the last few release cycles, and can now officially announce there is a new preprocessor implementation used inside ReSharper C++. There are two of them now, in fact – a newer one used for indexing, and an older one used for everything else. This new one delivers 15-25% faster indexing on typical solutions, like LLVM and Unreal Engine.
In code completion, ReSharper C++ shows a summary tooltip for each item in the completion list (controlled by the Show summary checkbox in the Environment | IntelliSense | Completion Appearance page of the ReSharper options). The description for the selected completion item is now colored and shows the documentation for the corresponding item.
The editor has even more code hints to help improve code readability. New hints were introduced after preprocessor directives and for function arguments that are passed by a non-const reference, while hints in aggregate initialization expressions now show the names of the initialized base classes.
The C++20 standard is almost ready to be signed off on by the C++ committee. And naturally, we are working hard to get fully compliant support in. ReSharper C++ 2019.2 got support for:
explicit,char8_t type,consteval and constinit specifiers,
Typing assist in multiline comments was improved. First of all, multiline comments that use single-line syntax are automatically extended. Second, extending multiline comments now inserts correct indentation when virtual space is enabled.
Wrapping code blocks with braces is now even easier – just select a block of code or an expression and then type an opening brace. ReSharper C++ will do the rest for you:
There are a whole bunch of new formatter options inside ReSharper C++ 2019.2:
New inspections are available to help you catch more code smells:
The Use static_cast fix for the C-style cast used inspection can be run in bulk and as part of Code Cleanup.
Code navigation actions got an accuracy-targeted update:
Besides, you can search in a file right through the Go to File member dialog. The result list will have names of all matched members, and all the places where the search string appears in the file.
In the previous release, we began to work towards better support for UE4-specific Remote Procedure Calls. Now, we've updated the Rename and Change Signature refactorings to work correctly on RPC functions. A few new code analysis checks are also available for UE4-based code, especially targeting the missing or incorrectly set UE4 reflection macros.
Following on from adding code completion for reflection specifiers in v2019.1, we've now added built-in documentation for them. It is shown in the Quick Documentation popup (Ctrl+Q) when the caret is located on a specifier.
ReSharper C++ 2019.2 provides initial support for the “Per-Monitor DPI Awareness” mode introduced in Visual Studio 2019. We’ve also updated the ReSharper | Options | Environment | Performance Guide page, adding a Windows Defender section as well as descriptions for all performance tips explaining what exactly will be done after a suggestion is applied.
There's some good news for plugin writers, too: C++ assemblies from ReSharper C++ are now included in the ReSharper SDK!
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 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++ understanding is enhanced further:
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:
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.
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.
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:
The formatter settings include many new options and enhancements:
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.
In unit testing, the following are now supported:
TEMPLATE_PRODUCT_TEST_CASE test declarations from Catch 2.7, andGTEST_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.
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.
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.
Support for C++/CLI is enhanced in v2018.3, offering lots of smart ways to generate missing C++/CLI code:
Equals() and GetHashCode()gcnewnew and foreach, in C++/CLI codeWhen 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.
If that wasn't enough, completion now uses default template arguments to provide suggestions in dependent code.
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.
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.
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:
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.
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.
This release also provides support for Catch 2.5 and its new templated tests.
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++.
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:
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.
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:
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.
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.
As usual, ReSharper C++ 2018.2 comes with many smaller improvements in different areas:
alignas specifiers, and __decltype(align) attributes.
for statements provide references over the colon for easy navigation to the
begin() and end() functions used by the loop.
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:
To learn more, see Step Filters in ReSharper C++.
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.
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.
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.
ReSharper C++ adds the following new built-in inspections:
if statements with if constexpr statements when the condition is a
compile-time constant expression.
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 has received a few enhancements:
Other changes to ReSharper C++ include the following:
#include_next preprocessor directive is now supported, for better compatibility
with compilers that implement this GNU extension.
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 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.
Improving C++ understanding was a major focus of the 2017.3 release, with several C++17 and C++14 features now supported:
The rest of the language-related changes include:
include_alias pragma directives.
ReSharper C++ 2017.3 comes with a set of new code inspections with accompanying fixes:
A couple of new context actions were also added:
class and typename keywords in a type template
parameter declaration.
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:
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.
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.
