ReSharper C++ joined the ReSharper fold back in 2015 to bring the power of ReSharper to the world of C++ – and has been getting better ever since! For most people this has rounded out the ReSharper story within Visual Studio. However an odd gap remains. Odd because the worlds of C++ and C# are bridged by the interop language, C++/CLI, yet this has remained unsupported by the ReSharper family.
Until now, that is!
From 2018.2 (available now in the EAP) ReSharper C++ has initial support for C++/CLI. There are some limitations, so read on to find out more. Support is enabled by default, but can be disabled by going to ReSharper | Options | Code Editing | C++ | Inspections, and unchecking “Enable C++/CLI support”. But we hope you won’t do that – especially as we’re also looking for user feedback and greater field experience.
A peculiar beast
As a rule nobody uses C++/CLI as a primary language. That’s not what it’s been designed for. While C# is a highly productive language, and is no slouch when it comes to performance, there are many reasons that we may also have a parts of our project written in pure C++. C++/CLI is an answer to the question, “how do I get to, or from, my pure C++ from C# (or any .NET language)?”. If you just need to call into C++, and it exposes a C API, P/Invoke may be the simplest way to go. But for more complex cases – where you want to model richer types and class hierarchies – C++/CLI let’s you do that. But it comes at the cost of a more complex language, with curious syntactic additions and sometimes tricky lifetime issues. So any help we can get from our tools while writing and maintaining this code is very welcome.
What is supported?
ReSharper C++ 2018.2 gives us initial support for C++/CLI projects. What does that mean? Well first it means that the parser and resolver now finally understand the extension system, with ^’s for CLR references, gcnew for allocating on the managed heap, etc. It also means that many static analysis features now work and can give us valuable insight. Note that, at time of this writing, there may still be a few limitations here. Please report these in our issue tracker so we can address them as quickly as possible.
Within C++/CLI code we have access to all the same great refactorings and intention actions as in pure C++ code. For example postfix templates are a great way to rewrite statements around a value. Where applicable these should work across C++/CLI and pure C++ codebases – for example you can rename a pure C++ symbol, or even a C# symbol, from within a C++/CLI usage. Again, some limitations may apply.
We can also navigate between C# and C++/CLI worlds. For example if we place the caret over a C++/CLI method name in some C# code you can now navigate to the definition in the C++/CLI code (note that this is referred to as “Go to declaration” in the menu, due to how these terms are used in C#). You can do the same going the other way, too.
For now there are some known limitations here. For instance from a C# project in the same solution, renaming a C++/CLI symbol is not an option. From the C++/CLI project, renaming a symbol referred to by the C# project wll rename it within the C++/CLI code, but not in the C# project. As mentioned already, renaming a native C++ symbol from a C++/CLI project works as expected, however.
Code generation is also limited for now, as generators for C++/CLI specific constructs, such as ref classes, have not yet been written. And the #using directive (for importing metadata in directly from a dll) is not supported at all – meaning both the use of the #using directive, as well as any symbols referenced from the dll, will currently be flagged as errors by the analyser.
We need your help
C++/CLI is unique in many ways. Software projects that make use of it tend to be larger enterprise style projects of in-house code bases that cannot be shared outside the organisation. There is very little in the way of non-trivial open source projects using C++/CLI. Here at JetBrains we only use it in some small ways internally to the ReShaper C++ implementation. So it is particularly difficult to build realistic test cases. As we move to expand our coverage we’ll rely a lot more on the community to tell us what’s not working (of course we’d also love to hear what’s working, too!) so we can do our best to address it and make our C++/CLI support first class.
As usual, please share your feedback with us and report issues either in the issue tracker or on the support forum.
Last week we published a detailed overview of ReSharper C++ 2018.1 changes. One of the major features for this release is Includes analyzer, a tool for locating and eliminating unnecessary header dependencies and thus upping compilation speeds. You can read about it in detail in this blog post. Today though, we’d like to give you a short demo recorded by Phil Nash, our C++ tools developer advocate. Watch the Includes analyzer in action and download the free 30-day trial of ReSharper C++ to try it on your project:
If you find Includes analyzer useful or have questions or comments about it, please use the comment section below or our issue tracker to share your feedback with us. We’ll be glad to know what you think!
We are pleased to introduce ReSharper C++ 2018.1, our first major update this year!
This release comes with two new important features. First, Debug Step Filters lets you avoid stepping into specific functions during debugging. Second, Includes Analyzer helps investigate the dependencies between header files that affect build times. Read on for more details about these features and other highlights of the 2018.1 release:
When you invoke Step Into, the Visual Studio debugger will normally step into all the functions that are called from the current statement. However, there are functions (like simple getters, setters, or dereference operators), which are either trivial or so well tested that you never want to step into them. This is where step filters come in: with this feature, you can specify the functions that should always be stepped over.
A step filter is defined by a regular expression, which is matched against the name of the function that the debugger is stepping into. You can inspect, configure, disable, or enable back step filters on the Tools | Debugging | C++ options page, which lists all the available filters.
ReSharper C++ comes with a predefined collection of step filters for the standard library, but you can easily add your own. You can come up with a custom regular expression that matches the names of functions to step over and manually add a filter from the options page. Or you can have ReSharper C++ automatically create one during a debugging session.
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 a new step filter. For template functions, there are separate context actions to add either only the current instantiation of the function template or all of its instantiations. If a matching filter has already been added to the list but was temporarily disabled, a context action will be available to enable it back.
The filters are stored using ReSharper’s layered settings. By default, the action to add a new filter follows the Smart Save logic, but you can use the action’s submenu to choose the layer to which the filter should be saved to. For example, you can use the Solution team-shared layer to make the new filter available to your teammates.
You might remember that Visual Studio has a built-in way to customize stepping behavior in C++, which is a part of C++ Just My Code. However, no user interface is provided for configuring this feature from the IDE, so you need to manually edit .natstepfilter XML configuration files to change existing or add new rules. Furthermore, there is no way to add solution-specific rules, since the configuration files are global. Please note that at the moment Visual Studio’s support for .natstepfilter files gets disabled if ReSharper C++ is installed.
Includes analyzer
Long build times is one of the biggest problems in large real-world C++ projects. ReSharper C++ already has a few tricks up its sleeve to aid you. For example, it will mark unused #include directives or automatically create forward declarations for unresolved names instead of simply including the headers with the required declarations.
ReSharper C++ 2018.1 introduces Includes Analyzer, a brand new code inspection tool that helps you speed up the compilation process.
Includes Analyzer is meant to help you locate and eliminate unnecessary header dependencies. A typical project might contain many thousands of #include directives, and it’s not clear which of them are worth investigating. Includes Analyzer attempts to estimate the contribution of each header file to the build time, based on the number of lines of code that it adds to the total compilation workload. While this is not a precise metric, it’s a useful starting criterion which can help you find and prioritize the most included header files.
After you identify the header dependencies that potentially have the biggest impact, you can try getting rid of them one by one via the standard approaches. These include: using forward declarations wherever possible, removing unneeded #include directives, applying the Pimpl idiom, splitting header files into smaller ones, and so on.
To start the analysis, invoke one of the ReSharper | Inspect | Analyze Includes in… actions from the main menu, or select Analyze Includes from the Solution Explorer context menu.
ReSharper C++ will analyze the files in the given scope and present a report in a dedicated tool window, where you can explore the dependencies between the files. The Includes analysis window provides two separate views, Includees and Includers, both of which present include dependencies as a tree where each node corresponds to a file. You can switch between the views via the corresponding toolbar buttons, or by navigating to the same file in the other view from the context menu.
The Includees view helps you understand how many lines of code the header file in a top-level tree node contributes to all source files that directly or indirectly include it. Child nodes in this view represent files that include the file from the parent node. Consider the following analysis of the entire Catch2 solution:
There are three metrics for each node in the tree:
Times included shows how many source files include the header in the top-level node through the path to the current node. In the example above, catch_common.h was included into 75 source files in total, of which 26 included catch_common.h through the #include "catch_common.h" directive in catch_tag_alias_autoregistrar.h.
Line contribution shows how many lines of code the header in the top-level node contributed through the path to the current node by itself, without transitively included files. catch_common.h contributed 4,050 lines of code in total, which is 75 (the number of source files that include it) times 54 (the number of lines of code in the file). Out of 4,050 in total, 1,404 lines were contributed because of #include "catch_common.h" in catch_tag_alias_autoregistrar.h.
Line contribution inclusive is similar to Line contribution, but this metric takes into account all headers transitively included into the file in the top-level node. E.g. catch_common.h, together with the headers included into it, contributes 2,654,938 lines in total during compilation of the entire solution. 1,017,626 of those lines were contributed because of #include "catch_common.h" in catch_tag_alias_autoregistrar.h. Line contribution inclusive is the default and arguably the most useful sorting criteria.
The Includers view is similar to the Includees view, but acts in the opposite way: the child nodes inside the tree represent files which are included into the file from the parent node.
This view shows how many lines of code are transitively included into the file in a top-level node as if it was compiled as a standalone source file (e.g. catch_common.h together with all headers included into it comprises 42,365 lines of code, of which 27,046 were brought with #include <string>). The metrics that this view provides are Includee count (the number of included files), Line count (the size of the file itself), and Line count inclusive (the size of the file with all the header files it includes).
One important limitation of Includes Analyzer is that ReSharper C++ does not actually run a full preprocessing stage in order to speed up the analysis process. This means that the line count does not in fact include the results of macro expansions, and that include guards do not get handled as well. Instead, ReSharper C++ assumes that each header file starts with an include guard or a #pragma once directive, and gets included at most once in any source file. Each successive include of the same header does not count towards its number of contributed lines, which means that sometimes you may encounter Times included and other metrics equal to zero next to an internal tree node.
In addition to navigation controls and the refresh button, the toolbar in the Includes analysis window lets you change two options:
Show only root nodes belonging to some project will hide top-level tree nodes that correspond to files not belonging to any project. This is a quick way to filter out library files if you want to concentrate only on headers inside your solution.
By default, ReSharper C++ skips blank lines and comments during an analysis. The Count blank and comment lines button lets you change this behavior.
We would like to give a shout-out to Header Hero, which inspired our own implementation of the same underlying idea. Check out the Caring by Sharing: Header Hero blog post, which introduces this great little tool and gives a few tips for improving project build times.
Navigation improvements
ReSharper C++ 2018.1’s biggest navigation update is the redesigned Go to File Member (Alt+\) dialog.
We have updated the dialog in several ways:
Class members in the open file are now grouped by their containing class in the results list.
With no search string active, file members are sorted in the order of their declarations inside the file.
The scrolling list with the results accommodates more items.
Together, these updates make the dialog more usable as they provide 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 omitting function and template parameters.
When you perform a search using the Recent Files dialog (Ctrl+,), 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 part of the continuous integration process, can now perform code formatting and cleanup in C++ projects. This instantly eliminates code style violations in a project or solution, and helps ensure a uniform code base.
To run the code cleanup tool on your solution, invoke cleanupcode.x86.exe from the command-line tools distribution with the path to the solution file. It will automatically reformat your code, fix common code style violations, remove redundant code, and optionally apply Clang-Tidy fix-its.
By default, command-line tools will use the predefined Full Cleanup profile, which includes the formatting stage and most (though not all) fixes for common code style issues, but skips the Clang-Tidy analysis stage. The other built-in profile is Reformat Code, which will apply only code formatting preferences. To use it, pass the profile name via the --profile command-line argument of cleanupcode.x86.exe:
You can also create a custom code cleanup profile. See our previous blog post entitled Code Cleanup with the ReSharper Command Line Tools for instructions on how to do this and more details about using cleanupcode.x86.exe.
ReSharper 2018.1 also fixes bogus errors which were output by the InspectCode tool on x64 projects. In addition, the upcoming 2018.1 release of TeamCity is able to run InspectCode on C++ projects (see TW-48978 for details).
Code inspections
ReSharper C++ 2018.1 adds several new built-in inspections:
A new inspection (with a corresponding fix and a code cleanup item) suggests replacing if statements with if constexpr when the condition is a compile-time constant expression.
Attempted usages of deleted functions are now diagnosed as errors, including usages via implicit function calls.
A new inspection warns about overriding destructors without the override specifier. There’s still debate in the C++ community whether destructors should ever be marked with override (for example, C++ Core Guidelines recommend against doing that), so the inspection is turned off by default. If you wish to use this inspection, please enable it on the Code Inspection | Inspection Severity options page.
Control flow and usage checking analyses have been updated to handle lambdas. This means that all the related inspections (unused variables and function parameters, unreachable code, redundant jumps, and many others), that previously worked only with functions, are also now available inside lambda bodies.
Finally, a minor change fixes the interaction between the Declarator is never used inspection and C++17 structured binding declarations. Previously, ReSharper C++ warned you about each unused structured binding separately from all the other bindings in the same declaration. We’ve changed this behavior so that if at least one of the structured bindings is used, the inspection does not trigger on any of the bindings.
Now all the major C++ compilers follow this logic, including MSVC starting with the update shipped in Visual Studio 15.7. If none of the bindings are used, you can still use the [[maybe_unused]] attribute to silence the inspection, but in practice you probably won’t ever need to.
More ways to configure inspection severity
In previous ReSharper C++ releases, inspection severity could only be set for the entire solution. But it is often required to be able to configure severity settings independently in different parts of the codebase, for example in legacy or test projects. In ReSharper С++ 2018.1, you can optionally enable the ability to have separate severity settings via the Read settings from EditorConfig and project settings option on the Code Inspection | Settings | General options page.
With this option turned on, you can set custom inspection severity using one of two approaches:
EditorConfig files. ReSharper C++ inspection severity can be specified inside an EditorConfig file using resharper_[severity id]_highlighting properties, where [severity id] is the name of the severity spelled in lower case with underscores. Depending on your needs, you can assign any value of do_not_show, hint, suggestion, warning or error to the property.
Please refer to the Index of EditorConfig properties web help page for the list of all EditorConfig properties that ReSharper C++ recognizes.
EditorConfig supports wildcard patterns in filenames, which means that inspection severity can be set independently even for specific files. A previous blog post entitled Configuring inspection severity with EditorConfig goes into more detail about using EditorConfig files, but do remember that you need to enable the option Code Editing | General Formatter Style | Enable EditorConfig support in order to have EditorConfig available.
Per-project DotSettings layers. If you do not want to use EditorConfig files, you can rely on ReSharper layered settings instead and create a project-level settings layer. Unfortunately, ReSharper C++ still does not include a dedicated UI for managing per-project DotSettings, but you can consult the Per Project Settings or How to have different naming styles for my test project blog post for instructions on how to create a project-specific settings file.
Please note that enabling granular inspection severity might have a noticeable performance impact on the speed of code analysis, depending on your configuration and the number of issues in a given file.
Clang-Tidy integration updates
Clang 6.0 was released this March. To keep up, we have updated the Clang-Tidy binary bundled with ReSharper C++, with several user-visible changes:
The following checks have changed their prefix from misc- to bugprone-: misc-argument-comment, misc-assert-side-effect, misc-bool-pointer-implicit-conversion, misc-dangling-handle, misc-fold-init-type, misc-forward-declaration-namespace, misc-inaccurate-erase, misc-move-forwarding-reference, misc-multiple-statement-macro, misc-string-constructor, misc-use-after-move, misc-virtual-near-miss.
The following checks have changed their prefix from misc- to performance-: misc-inefficient-algorithm, misc-move-const-arg, misc-move-constructor-init, misc-noexcept-move-constructor.
Another new Clang-Tidy feature from the 6.0 release is the extended syntax of the NOLINT comment, which now accepts an optional list of check names to silence. ReSharper C++ adds a new inspection action that utilizes the new syntax and lets you disable a specific Clang-Tidy diagnostic on the current line:
We have also received several reports of Clang-Tidy crashes, with Windows displaying crash notifications as a result. While the ReSharper C++ team cannot fix the crashes themselves, we have changed the default error reporting mode used by the clang-tidy binary to prevent the annoying message boxes.
Other changes
Unit testing support includes two minor updates:
ReSharper C++ 2018.1.1 fixes compatibility with Boost.Test from Boost 1.67 (which was broken because of a bug in Boost.Test).
The new setting Tools | Unit Testing | C++ Tests | Use command-line arguments… lets you manage whether ReSharper C++ should use the value of the Debugging | Local Windows Debugger | Command Arguments project property when running unit tests.
Other changes to ReSharper C++ include:
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. You can use this ability, for example, to quickly evaluate a type trait for a specific type:
The /Y- (ignore precompiled header options) and /Zc:__cplusplus (enable the updated value of the __cplusplus macro) command-line MSVC compiler arguments are supported.
The performance of the completion pop-up and start-up time have been improved in several cases.
If you’d like to learn more about how C++ tools can improve your development workflow, Anastasia Kazakova (C++ tools PMM at JetBrains) recently gave a talk at the ACCU 2018 conference entitled Debug C++ Without Running. In her talk, Anastasia discusses a few peculiarities of the C++ language that contribute to its notorious complexity and demonstrates some helpful features from ReSharper C++, CLion, and other C++ tools.
As usual, please share your feedback with us and report issues either in the issue tracker or on the support forum.
It hasn’t been long since the first debugging-assistance features — inline values, searchable DataTips, and breakpoints navigation — appeared in ReSharper, but today we’re happy to present yet another cool feature — step filters in C++.
Why do you need step filters? Well, the illustration below explains pretty much everything:
Some functions never need to be stepped into because they are either very simple or very well tested. But the problem is that the debugger cannot tell which functions are worth debugging and which aren’t, and therefore Step Into will not miss any user function on its way.
Visual Studio’s Just My Code functionality takes basic care of this problem by ignoring non-user code and letting you customize ignored symbols using text config files.
However with ReSharper C++, you can now visually maintain step filters — a list of function masks that tells the debugger what should be skipped on stepping. By default, this list includes a lot of library functions and it can be extended.
Of course, ReSharper wouldn’t be ReSharper without having some handy goodies here: to quickly add a function to the filters, you can press Alt+Enter on that function while debugging and pick the corresponding action:
The filters are stored using ReSharper’s layered settings. By default, the action saves the filter in the ‘Solution personal’ layer, but you can use the action’s submenu to choose where the filter should be saved — e.g in the ‘Solution team-shared’ layer, so that this filter will be also available to your teammates.
You can study and further configure step filters on the Tools | Debugging | C++ options page:
ReSharper C++ 2017.3 has been one of our biggest updates yet in terms of both new features and fixed issues.
Without further ado, let’s dig into the notable changes it brings:
Clang-Tidy is a powerful open-source code analysis tool based on the popular Clang compiler. It comes with an extensive set of code checks and accompanying fixes for typical programming errors.
ReSharper C++ 2017.3 provides seamless integration with Clang-Tidy. This means that as you edit a file, ReSharper C++ runs Clang-Tidy on it in background as a separate process, with inspection results shown right in the editor alongside other ReSharper C++’s inspections. Unsaved files are handled transparently by saving the text of the current document to a temporary file and instructing Clang-Tidy to use it instead of the on-disk version.
To distinguish between Clang-Tidy checks and ReSharper C++’s inspections, look at the name of the check in square brackets, appended to the inspection message.
In addition to diagnostics from Clang-Tidy checks, Clang-Tidy also issues diagnostics from 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 adjusted to meet your needs on the Inspection Severity options page.
Some of the Clang-Tidy checks that duplicate ReSharper C++’s built-in inspections are turned off by default. In addition, all static analyzer checks are disabled, since enabling them significantly slows down Clang-Tidy.
As with the built-in inspections, you can use the inspection context menu to quickly change the severity of a Clang-Tidy check, or to disable it via a comment. There is also an additional action that opens the online documentation page for a particular check.
ReSharper C++ lets you apply the fixes provided by Clang-Tidy similarly to its own built-in quick-fixes. As with other bulk fixes, Clang-Tidy fixes can be applied individually or inside a specific scope (file, folder, project, or solution).
By default, ReSharper C++ will reformat code changed by Clang-Tidy to maintain the code style. This behavior can be disabled via the Reformat changed code after applying Clang-Tidy fix-its setting to speed up fix execution.
Clang-Tidy fixes can also be applied from code cleanup. Built-in code cleanup profiles do not include the Clang-Tidy stage, so to enable it you need to create a new profile and select the Clang-Tidy checks which will be enabled during a code cleanup run.
The selected checks will be enabled even if they are turned off on the Inspection Severity options page. Please be careful when enabling too many checks at once — code cleanup runs Clang-Tidy only once for a given file, so if multiple fixes touch the same block of code, the changes might conflict with each other.
ReSharper C++ does not write its own Clang-Tidy config, so a user-provided one can be picked. Clang-Tidy attempts to read configuration for each source file from a .clang-tidy file located in the closest parent directory of the source file. The source file here (as with the rest of ReSharper C++ inspections) is the .cpp file itself if the analysis is run on it, or a random .cpp file which includes the header when the analysis is performed on a header file. Alternatively, you can use the Clang-Tidy config ReSharper setting to pass a string with custom configuration to Clang-Tidy via the -config command-line option.
The -checks command line option is used to pass the list of enabled checks to Clang-Tidy, which then gets appended to the value of the checks option read from the Clang-Tidy config. To construct the -checks argument, ReSharper C++ takes the value of the List of enabled/disabled Clang-Tidy checks and appends to it the names of checks which are turned off on the Inspection Severity options page.
We needed to make a few modifications to Clang-Tidy to facilitate its usage from the IDE, so unfortunately a custom Clang-Tidy binary cannot be used at the moment. ReSharper C++ 2017.3 is shipped with a version of Clang-Tidy built from the trunk, and we plan to update it to the final Clang 6.0 version in ReSharper C++ 2018.1.
There are a few caveats to Clang-Tidy integration that we are aware of:
Files using UTF-16 or UTF-32 encoding cannot be read by Clang and thus are not supported by Clang-Tidy at the moment.
Sometimes Clang-Tidy might crash on your code, and Windows will show you the “Process has stopped working” message. In this case please disable Clang-Tidy integration for the current solution (see how below). We’ll update the bundled binary in 2018.1 so that this message is not shown.
There are several ways to disable or enable Clang-Tidy integration:
Via the Enable Clang-Tidy support setting in ReSharper options.
Through the Enable Clang-Tidy analysis toggle in the status indicator context menu:
With the Ctrl+Shift+Alt+9 keyboard shortcut.
Debugger features
ReSharper C++ 2017.3 is the first release that brings debugger-related features to the table. The most useful of them is inline watches: ReSharper C++ will display local variables, function parameters, current line expressions, and function return values right inside the editor. This feature provides immediate feedback during debugging sessions, which means that often you don’t even have to consult the Watches or Autos tool windows.
ReSharper C++ is careful to evaluate only those expressions that do not have side effects. At the moment, expression evaluation is limited to references, constants, member access, and built-in subscript operators. Subscript operators of std::vector and std::array are also evaluated as an exception. Please note that inline watches use the Visual Studio debugger engine to evaluate expression, which means that Natvis files with user-provided visualization rules are automatically supported.
ReSharper C++ also comes with its own debugger DataTips, which provide several advantages over their Visual Studio counterparts:
You can quickly search for a string inside a DataTip (just start typing with the DataTip open).
You can mark members of a class which will be used to construct a custom presentation string for objects of this class. To do this, invoke Highlight Property from the context menu on class members that you are interested in.
Unlike Visual Studio DataTips, ReSharper DataTips do not disappear when the mouse pointer leaves the DataTip window area.
To access ReSharper DataTips, just click the inline value display. If you find ReSharper DataTips helpful, you can replace Visual Studio DataTips with ReSharper’s by enabling Override VS DataTips with ReSharper DataTips on the Tools | Debugger ReSharper options page.
Working with multiple breakpoints should now become easier. The new Go to Breakpoint action (Ctrl+Alt+F9) displays breakpoints in a context menu so that you can quickly navigate between them. In addition, the dedicated R# Breakpoints tool window (ReSharper | Windows | Breakpoints) groups breakpoints and displays the line of code where each breakpoint was set.
Breakpoints and tracepoints can also be created directly in the Find Results tool window, from the occurrence context menu.
But that’s not all — we are working on adding new debugger-related features. In particular, ReSharper C++ 2018.1 will bring debug step filters, a feature which lets you make the debugger step over certain functions (e.g. subscript operators or trivial getters). If you are interested in trying it, head over to the Early Access Program page when the EAP starts and install the latest available ReSharper 2018.1 build.
Language understanding
For the 2017.3 release, we specially focused on improving the product’s understanding of C++. We made sure the following new C++17 and C++14 features received support:
C++17 structured binding declarations allow declaring multiple variables that bind to subobjects of another object. This is particularly useful when working with functions that need to return multiple values. As with other identifiers, you can determine the actual types of structured bindings via ReSharper C++’s tooltips or the Quick Documentation popup.
Structured binding declarations support binding to array elements, public class data members, and tuple-like objects. Making your own classes support the tuple-like binding protocol requires specializing std::tuple_size and std::tuple_element, and if something goes wrong, ReSharper C++ will provide you with detailed error messages.
Return type can now be deduced for C++14 auto functions without trailing return types.
Supporting this language feature was rather complicated because, to determine the return type of a function declared in a header file, its body is needed. On the upside, implementing it also allowed us to fully support C++17 constexpr if statements, which can cause a function to have different return types depending on which constexpr if branch is chosen.
Type checking and return type deduction now work for lambda expressions, including support for C++14 generic lambdas.
Previously only functions could be declared as inline, but in C++17 variables can be declared inline too. This is now supported by ReSharper C++, and a warning will be issued when the inline specifier is required to avoid linking errors.
All in all, this brings ReSharper C++ almost to the level of standard C++ support provided by the Visual C++ compiler at the moment, with two notable features still in our queue to implement — fold expressions and evaluation of constexpr functions.
Other language-related changes include:
ReSharper C++ now understands include_alias pragma directives, which allow mapping any header filename to another.
Improved support of explicit template instantiations. In particular, explicit instantiations of both class and function templates are now handled correctly by the Rename refactoring, and can be navigated to via gutter icons.
ReSharper C++ 2017.3 extends its set of available code inspections:
Binary operators with suspiciously looking identical or equal operands will be highlighted.
Default arguments on virtual functions are considered bad style (see e.g. Google’s C++ style guide for details). ReSharper C++ now includes an inspection which finds redefinitions of a default argument from a base function.
const and volatile specifiers on parameters in a function declaration have no effect and will be shown as dead code.
Function parameters that are not mentioned in the function documentation comment will be underlined, with a fix to insert the corresponding documentation line.
Member initializers in constructors that duplicate the corresponding default member initializers will be marked as redundant.
All user-defined literal suffixes must start with the underscore character according to the C++ standard. ReSharper C++ will warn you about literal operators that violate this requirement.
A couple of context actions were also added:
An action to move a member initializer from a constructor member initializer list to a default member initializer.
An action to switch between class and typename keywords in type template parameter declarations.
Code formatting
If you wish to preserve custom formatting just inside a block of code, ReSharper C++’s formatter can now be selectively disabled by wrapping this block with a pair of comments containing formatter directives: // @formatter:off to disable formatting, and // @formatter:on to enable it back.
Instead of disabling the formatter completely, you can configure it using inline EditorConfig-style settings and override only one or several of them, keeping common code style settings active. Please refer to the EditorConfig Properties help page for the list of supported properties.
Another long-requested formatter feature is the ability to align specific code elements in columns, which is now supported for assignment statements, declaration names, and single-line comments (configured by a family of settings in Indentation and Alignment | Align Similar Code In Columns).
There’s also a related multiline alignment setting, which controls the outdenting of command and member access operators in chained method calls.
The layout of linkage specification blocks can now be customized via two formatting settings, Indentation | Indent linkage specification block members and Braces Layout | Linkage specifications. The usual idiom of using extern "C" blocks in header files to create an API compatible with C is now supported:
Finally, two new settings, Spaces | Before/after commas in uniform initialization braces and Spaces | Before end of line comment, provide more options to match spacing in your code.
Navigation improvements
The Go to Declaration command is now available on dependent names inside definitions of templates. This should make it much more useful in template-heavy code. Since ReSharper C++ has no way of finding the exact entity that the name refers to, instead it will look through all the symbols and offer those with matching names and signatures as potential navigation targets.
In addition, Go to Declaration now lets you navigate from a member function definition to a declaration with a non-matching signature if no matching declaration is found. This ability comes in handy when you change the definition and need to update the declaration (even though we encourage you to use the Change Signature refactoring and related fixes for this purpose).
To-do patterns get a URL field, which creates a link in your code for navigating to external resources by Ctrl+Click on the to-do item, or via the Alt+Enter shortcut. This helps you keep your to-do comments brief and straightforward: no full URLs are needed, only an issue ID. Links in to-do items support the Peek Preview feature to display the linked issue inline in the editor. Also, you can easily locate the to-do item in To-do Explorer via the Alt+Enter menu.
Smaller navigation-related changes include:
Search Everywhere always shows text matches in a dedicated section, even when there are other results. So, you do not need to switch to Go to Text when you want to take a peek at text occurrences.
When occurrences are shown in the Find Usages window, ReSharper C++ considers and presents the context (e.g. function calls or return statements) from the surrounding lines.
The redesigned preview pane in ReSharper tool windows (shown above) and formatter options pages are now based on the Visual Studio editor. This gives preview pane code a more natural look: keywords and strings are highlighted, identifier colors are applied, and font settings and scaling are inherited from Visual Studio’s text editor settings.
Other changes
Catch2, the latest version of the popular Catch unit testing framework, is now supported. Its codebase has been updated to use C++11, with strong focus on both compile and runtime performance. If you are interested in learning more about new Catch2 features and Catch in general, a good place to start would be the announcement blog post and the Modern C++ testing with Catch2 talk by Phil Nash, the author of Catch.
The Performance Guide page in ReSharper options 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.
While it does not have any C++-related tips yet, it can still help you improve the general responsiveness of your development environment.
Generative completion now allows creating definitions not only for member functions, but also for free functions.
Built-in live templates cctor and mctor which expand to a copy and move constructor, accordingly, were added.
We’ve added the setting Use trailing return types in generated function declarations (in ReSharper | Options | Code Editing | C++) for trailing return types afficionados. When it is enabled, various code generation features will create function declarations with trailing return types instead of using the classic return type style.
Numerous performance issues were resolved. Most importantly, typing assist and completion lags in Visual Studio 15.5 and slow renaming of files were addressed. Additionally, nested queries in Go to Symbol should execute much faster now.
We hope you find the new features useful! Please leave us any feedback and report issues either in the issue tracker or on the support forum.
ReSharper C++ 2017.2 has finalized support for several C++11 features:
In addition to user-defined integer literals, ReSharper C++ supports floating-point, character, and string literals. Find Usages and Rename were also updated to handle literal operators.
Expression SFINAE support was improved in several ways. Most importantly, overload resolution results are now checked inside expressions during template substitution.
More standard type traits are supported, including all traits with names prefixed by is_trivially.
Visual Studio 15.3 comes with a significant update for its C++ toolset. The following new C++17 features introduced in 15.3 are now also supported by ReSharper C++:
Selection statements with initializer (P0305R1) — the extended syntax for if and switch statements which allows initializers:
Code inspections understand the C++17 attributes [[nodiscard]] (P0189R1) and [[maybe_unused]] (P0212R1):
Using attribute namespaces without repetition (P0028R4):
Unfortunately, structured binding declarations from C++17 are not yet supported, but they are top-of-the-list for our next release.
On a related note, another important change in the 15.3 toolset is partial support for two-phase name lookup. It has to be manually enabled through the /permissive- conformance switch, but MSVC’s team plan is to turn conformance mode on by default in the next major compiler revision. If you want to move your code forward and make it fully two-phase clean, ReSharper C++ can be a great aid since it has been using two-phase name lookup since the beginning. You just need to pay attention to warnings inside template code—for example, ReSharper C++ will point out lookup errors during the first phase of lookup:
For help with errors related to two-phase name lookup, we have suggestions about missing template and typename keywords in dependent code:
There is some news about C support as well. ReSharper C++ now implements anonymous structures, a Microsoft C extension that allows declaring a structure variable within another structure without giving it a name. Members of anonymous structures can be accessed as if they were members in the containing structure. This extension is limited to C only, but it is supported both by Clang and GCC with the -fms-extensions option.
If you need to override a few functions from a base class, there is now an alternative to using the Generate overriding members dialog. Virtual functions that can be overridden will be included into the completion list when you complete inside a class body. When selected, these completion items will insert a full function declaration. To continue, you can use Generate implementation or Generate inline implementation – either context action will create a function body.
Finally, the Generate constructor dialog got a new option, Make empty constructors = default. As the name suggests, with this option enabled ReSharper C++ will = default the generated constructor when it is empty, so it’s a quick way to add a defaulted constructor if you need one in your class.
Code inspections and quick-fixes
ReSharper C++ 2017.2 adds several new code inspections:
The much-requested Inconsistent Naming inspection detects violations of naming style in your code, and the accompanying fix allows you to quickly invoke the Rename refactoring with the name changed according to the corresponding naming rule. By default, the naming inspection has the Hint severity, which means that naming inconsistencies do not appear on the marker bar and are not highlighted with curly underlines. If you want to enforce naming rules and find that this inspection is useful, do change its severity to Suggestion or Warning.
Naming rules used by the inspection can be configured on the Code Editing | C++ | Naming Style options page. This page has been reworked since the previous release and now allows adding new names rules and editing existing ones. The rules are checked in reverse order, meaning that a rule that comes later in the list has higher priority than the one before it.
For each naming rule, it is possible to specify the kinds (e.g. class, function or variable), accessibility, and specifiers (static, const, constexpr or volatile) of entities to which the rule should apply. Please note that the naming rules for getters and setters, which are present in previous versions of ReSharper C++, are now gone. You can use new options in the Generate getters and setters dialog instead to control whether or not to add is/get/set prefixes to getter and setter names.
One of the unique ReSharper C++ inspections is Member function may be const, which highlights functions that do not change member variables of the containing class and thus can be marked as const. ReSharper C++ 2017.2 adds a couple of related inspections, Local variable may be const and Parameter may be const (since 2017.2.1), which perform a similar analysis and show local variables and function parameters that can be made immutable.
If you consider using const everywhere possible as too excessive, reduce the severity of one or both of these inspections.
Unused entity inspections used to work only with local variables and function parameters. Their scope has been extended now to also include global variables, classes, enums, and enumerators that have internal linkage or are members of an anonymous namespace.
A number of new quick-fixes for existing inspections were also introduced:
Add #pragma once is the recommended fix when an include guard is missing in a header file. There are teams though that prefer using #ifndef/#define/#endif include guards, and ReSharper C++ now has a fix that wraps the header file with this combination of directives.
If there is an unused expression without any side effects inside a function of a type compatible with the function’s return type, ReSharper C++ lets you convert it into a return statement via the Return unused expression fix.
Trying to bind lvalue expressions to rvalue references is a compiler error, but sometimes it just means that a call to std::move was intended but is missing. To quickly add it, use the new Add std::move fix.
ClangFormat support and line wrapping
ReSharper C++ 2017.1 brought support for EditorConfig, a popular standard for defining code formatting preferences. In the C++ community, however, ClangFormat is the de facto standard for formatting tooling. ReSharper C++ 2017.2 adds support for reading ClangFormat configuration files, so if there is one in your project, ReSharper’s code formatting engine will automatically pick it up and use it. To find the configuration files that affect a particular file, ReSharper C++ looks for .clang-format and _clang-format files in the containing folders. ReSharper C++ will also help you understand exactly which style options are applied and where they come from:
You will see a yellow warning on ReSharper C++ formatting options pages if at least one preference on a page is overridden by ClangFormat options. Each overridden preference will be also highlighted with yellow:
You can see and study all ClangFormat configuration files that affect the current file in the File Formatting Info window:
Please refer to the Using Clang-Format help page for the full list of supported ClangFormat style options.
Another big change related to code formatting is support for line wrapping. You can find the option to turn it on or off, as well as a collection of options that control wrapping inside different syntax elements, in the Line wrapping group on the Code Editing | C++ | Formatting Style | Line breaks and Wrapping options page.
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 and their contents in function declarations, function calls, and if/while/for statements; and
spaces around colons in range-based for loops and in lists of base classes.
Navigation features
Go to declaration now works inside the bodies of macro definitions. Of course, due to the textual nature of preprocessor macros, the results of such a context search are tentative. For macro parameters, the search will jump to the parameter declaration. For other identifiers inside macro bodies, all symbols inside the solution with names that match the identifier will be shown.
Go to Everything(Ctrl+T), Go to File Member(Alt+\) and Go to Action (Alt+Enter) have been improved as follows:
The query syntax got extended in several ways. ReSharper will now match identifiers even if the word order inside your query is mixed up:
On the other hand, if you add quotes around a search query, ReSharper will only look for exact matches. If you need even more control, it is also possible to combine exact search with wildcard characters like * and ?.
To streamline the navigation experience, Go to Text is integrated into Search Everywhere, so you do not need to deliberately use Go to Text to get text matches in search results.
A laptop-friendly Shift+Enter shortcut can now be used in addition to Num + to open search results in a separate Find Results tool window, where you can explore and filter items more easily.
Navigate to file nearby is a completely new navigation feature, which displays project structure around the current file in a popup menu. The top-level menu shows the solution, the current project, containing folders, and files in the same folder. From there you can navigate deeper, open files, and create new files and folders. Navigate to file nearby is not bound to a key shortcut by default, but it can be invoked similar to other navigation actions from the Navigate To context menu (Alt+Backquote) or via ReSharper | Navigate | Go to File Nearby.
ReSharper C++ 2017.1 introduced the option to not reindex includers when preprocessor directives in a header file get modified. In the 2017.2 release, another common situation which caused bulk reindexing is addressed using a similar mechanism. By default, ReSharper C++ will now not reindex files after the current build configuration of a project is changed. Please note that code inspections may execute slower after a configuration change the first time you open a file, since ReSharper C++ will need to reparse the included files. If you prefer the old behavior, you can revert via the option Code Editing | C++ | Performance | Reindex affected files after a project or a file property is changed.
The second performance-related change is added support for the new asynchronous Visual Studio API for reading project properties, available starting with Visual Studio 15.3. In the past, ReSharper C++ had to query project properties on the main thread, which could lead to UI stalls when you opened your solution or changed project configurations. These freezes should be gone now, with the additional benefit of lower memory usage for storing project properties. Moreover, the lightweight solution load Visual Studio feature is now supported, and ReSharper C++ should no longer force loading of all projects in the solution even when LSL is enabled. If you encounter ReSharper C++ issues when running Visual Studio 15.3, please try disabling the option Code Editing | C++ | Performance | Read project properties asynchronously in Visual Studio 15.3 and later and reopening the solution. If it does help, do let us know!
CppCon 2017
This year’s biggest C++ conference takes place in Bellevue, Washington, USA on September 24–29. JetBrains is proud to return as a bronze sponsor and will have an exhibition booth set up on the 27th and 28th. If you’re there, stop by the booth to have a chat with members of our CLion and ReSharper C++ teams, give them your feedback, and consider attending one or more of the talks delivered by JetBrainers:
New standards to the rescue: the view through an IDE’s glasses, by Anastasia Kazakova (CLion Product Marketing Manager) at 2 pm, September 25.
Tools from the C++ eco-system to save a leg, by Anastasia as well at 3:15 pm, September 26.
The Holy Grail—A Hash Array Mapped Trie for C++, by Phil Nash (JetBrains developer advocate and the author of the famous Catch unit testing framework) at 9 am, September 29.
We are looking forward to seeing you there!
That’s it! Start your free 30-day evaluation and try out all the new features and fixes. As always, please leave us any feedback and report issues either in the issue tracker or on the support forum.
Today we are happy to share our next compilation of C++ news with you.
Subscribe to the regular C++ Annotated and be the first to get the next edition!
C++ Annotated: April – August 2017
A long time has passed since the last edition of C++ Annotated. Which means today we have lots of great articles and news to share with you. In this edition:
C++ language news
C++20
Metaclasses
Conferences
Recent events like ACCU and C++Now
Upcoming events
Learning
Releases
C++ language news
C++20
With C++17 ready for final publication by the end of 2017, we can now start thinking about the future of C++ and in particular C++20. The Toronto C++ committee meeting was solely about just this! Just look:
Concept TS was merged into C++20 draft. It takes now only one clean syntax (out of three) and doesn’t include function concepts.
Coroutines TS, Networking TS and Ranges TS are done, Modules TS is quite close.
Several nice enhancements like designated Initializers, template syntax for generic lambdas, default member initializers for bit-fields and others.
ReSharper Ultimate 2017.1 is out! It’s been some time since our last post about updates in ReSharper’s C++ support, so let’s take a look at what has kept the team busy.
Major areas of improvements include:
Visual Studio 2017 has launched, bringing a lot of new features and improvements to C++ developers. ReSharper C++ 2017.1 has full support for the latest Visual Studio release, including:
The handling of the v141 toolset, the C++ Language Standard project property and the equivalent /std compiler command line argument.
Support for the Enable Faster Project Load IDE option.
Most importantly, ReSharper C++ introduces initial support for the Open Folder functionality and CMake-based projects in Visual Studio 2017. The latter is particularly helpful since it eliminates the need to regenerate and reload the Visual Studio project when CMakeLists.txt is modified. However, there are a couple of related caveats:
In the Open Folder mode without a CppProperties.json configuration file present, ReSharper C++ will use include paths set via the INCLUDE environment variable. You can start Visual Studio from the developer command prompt to have INCLUDE automatically populated with paths to the standard library and Windows SDK.
Since there is no Debugging property page, additional configuration is required if you want to use ReSharper’s unit testing capabilities. You can specify how to run tests on the new page, Tools | Unit Testing | C++ Tests, in ReSharper options.
Please note that support for this kind of projects is still experimental — do let us know if you experience any problems!
We’ve also updated ReSharper C++ to handle several new types of projects — properties like predefined macros, include paths, and others should be correctly read from VisualGDB MSBuild, Linux Makefile, and CUDA projects. Moreover, when a compiler other than MSVC is used, ReSharper C++ predefines a number of macros for better compatibility with GCC and CLang compilers.
Language features
C++17 nested namespace definitions are now supported in ReSharper C++. Available since VS 2015 Update 3, this feature provides a concise way of defining nested namespaces. When ReSharper C++ detects that the latest language standard is being used, the Convert to nested namespace definition context action is available to change the old-style syntax into the new one:
A couple of new refactorings were implemented to complement the existing Substitute typedef context action. The Introduce typedef refactoring allows you to quickly create a typedef for the selected data type and replace this data type and all its occurrences with the newly created typedef. The Inline typedef refactoring does the opposite: it replaces an existing typedef with the actual data type.
Needless to say, these refactorings also support C++11 type aliases. If you want the Introduce typedef refactoring to insert a type alias instead of a typedef declaration, set this behavior on the options page Code Editing | C++ | Code style.
Unit testing
In addition to Google Test and Boost Test, ReSharper C++ 2016.3 delivered first class support for Catch, a cross-platform test framework for C++. Catch is popular because of its ease of use and expressive API, which allows you to divide test cases into sections (each of which is run in isolation) and structure them using BDD style. The framework is distributed as a single header file, with no external dependencies (beyond the C++03 standard library). You can always get the latest version of this header directly at this URL. For an introduction to Catch, please refer to the Catch tutorial, watch the CppCon presentation, or read the article in the CLion blog.
We are also happy to say that the author of Catch, Phil Nash, joined JetBrains as a developer advocate last fall. If you have any ideas on how to improve Catch integration into JetBrains products or have feature suggestions for Catch itself, do not hesitate to contact him!
Other updates in unit testing support include:
Boost Test runner has been updated to support Boost 1.62, 1.63 and 1.64. We have also fixed performance issues while working with a large number of dynamic tests and changed the runner to ignore output from the test program, so it does not affect parsing of the XML test report.
Google Test runner now supports the 1.8 release of the framework. ReSharper C++ will also correctly merge results of several runs and calculate total execution time if the --gtest_repeat flag is used to run the tests several times.
The list of unit tests is now automatically updated after external file changes (for example, when unit tests are generated as a result of a build step).
Completion
Postfix templates, a popular feature first introduced by ReSharper for C#, allow you to focus on your data rather than the syntax. ReSharper C++ gets a set of its own templates specifically tailored for C++. You can now quickly wrap an expression with several available templates, including if, else, while, do, return, switch, foreach, and others.
The new options page Code Editing | Postfix Templates lists all the available postfix templates. It allows you to disable the ones you do not use, and contains a number of related options.
One common C++ coding practice is to prefer non-member non-friend functions to member functions. This is a great way to increase encapsulation and keep class interfaces as minimal as possible (see item 32 in Scott Meyer’s “Effective C++” for a detailed discussion). However, from the tooling perspective there have always been drawbacks to this practice. Whereas member completion list shows all the available member functions, it’s not so easy to list and complete non-member functions which are applicable to an object of the given class. This problem is now solved by ReSharper C++: when you type a dot (.) or an arrow (->) after an expression, free functions that accept that expression as the first parameter will be suggested in the completion list as well as member functions.
Code cleanup and inspections
ReSharper C++ 2017.1 introduces cleanup tasks, including:
A set of tasks to apply the existing quick-fixes for common code issues.
The Update file header cleanup task, which updates the comment at the top of the file according to the template specified on the options page Code Editing | File Header Text (take a look at the related blog post for more details).
To run code cleanup, use the command ReSharper | Edit | Cleanup Code (Ctrl+E, C) — it will work either with the current text selection, the entire file opened in the text editor, or on a set of files and projects selected in the solution explorer. You have the choice to use the built-in profile (which has several of the tasks that you might not always want to run disabled) or create your own. Here’s one that shows all the available C++ cleanup tasks:
Control flow inspections (uninitialized/reassigned/unused variable and the like) used to work only with local variables and function parameters, but now class fields are also analyzed. For example, ReSharper C++ will find a self-initialization error in this snippet:
Or an uninitialized member here:
If you declare a local variable and initialize it later without any conditions, ReSharper C++ now suggests to join declaration and assignment where the variable is first initialized. This removes the unnecessary statement and improves code readability.
We have introduced several ReSharper-specific C++11 attributes that can be used to improve the results of certain inspections. For example, ReSharper C++ now understands the [[rscpp::format]] attribute (or, alternatively, [[gnu::format]]), which can be used to enable printf format string analyses for user-defined functions (RSCPP-15890).
There are also attributes to mark functions as having side effects (see RSCPP-18615) and guard classes for which the Unused variable highlighting should be suppressed (RSCPP-18764) — please refer to the corresponding issues for examples of their usage.
A number of smaller new code inspections were also added:
Incrementing expression of type bool and Deprecated register storage class specifier for language features removed in C++17.
Deleting a void pointer is undefined behavior according to the C++ standard.
Redundant void argument list (void argument lists are only useful in C code).
Private special member function is not implemented, which reminds you to use the C++11 = delete specifier instead of making the function private and omitting its definition to prohibit its usage.
ReSharper’s File Status Indicator (the small icon at the top of the Error Stripe) receives a new context menu. With a right-click on the icon, you can quickly toggle not only ReSharper code analysis, but also identifier highlightings and Visual Studio code analysis (the lightbulb and squiggles). If there are code issues in the current file, you’ll also see commands for navigating between issues of the highest severity level (you can still use the good old Inspect | Next/Previous Error/Warning commands to do that).
Finally, a new option on the options page Code Editing | C++ | Inspections controls the visibility of gutter icons (like “Navigate to definition/declaration”), should you find they clutter the user interface too much for your liking.
Documentation support
ReSharper C++ 2016.3 finally learned to display rich syntax-highlighted tooltips for C++ code elements. The contents of the tooltips mirror what was previously available through the Quick Documentation popup, namely function and variable types, containing namespace, template and function parameters, as well as documentation comments.
In addition to the standard Doxygen syntax, ReSharper C++ now understands C#-style XML documentation comments.
Finally, while only references to function parameters were resolved before from inside documentation comments, now template parameter references are also supported. This means that they will be shown in the list of results from Find Usages and updated by Rename when it is used on a template parameter.
Command line tools
ReSharper Command Line Tools (CLT) are a standalone set of command line tools that enable you to run code inspections outside of Visual Studio (for example, on your CI server or code quality management system). You can now use inspectcode.x86.exe from the CLT distribution to analyze C++ projects and generate a report with found code issues. What’s the best part? CLT are free and do not require an active license. To analyze your solution, just run inspectcode.x86.exe -o=report.xml YourSolution.sln.
You can either get CLT via a NuGet package or download a standalone archive. In the latter case ensure that the downloaded .zip file is “unblocked” before extracting: right click on the file, select Properties and click Unblock. (Failure to do this will cause the .NET framework to load the application in partial trust, which means it won’t load or run correctly.)
In terms of performance, we have recently targeted ReSharper C++’s memory usage to make it work better with huge solutions. (Since we still run in-process, we’re limited by the amount of memory Visual Studio can use as a 32-bit process.) As a result, both the memory footprint after indexing and memory traffic during indexing have improved significantly. In some cases (like the Unreal Engine 4 solution), the amount of managed memory used has decreased by up to 30%. Furthermore, a number of issues have been resolved that had caused excessive memory usage due to background editor and Find Results tabs. All of these changes should help with the debugging experience, since additional memory usage during debugging might have led to memory pressure. If you had problems with debugging before, we would also recommend trying Visual Studio 2017, which improves memory usage during debugging.
In C++ code, when you change preprocessor directives in a header file anything can happen. For example, if you add a #define or #include some file into a header file, the meaning of code can change in any file that uses that header. ReSharper C++ used to reindex all includers after a change like this, which is quite taxing on big projects, especially for common headers which get included into most C++ files. We have revisited this behavior, and now ReSharper C++ does not reindex these files by default, so the symbols in them are still used for navigation and refactoring purposes. This is a compromise between correctness and speed, the old behavior can be restored using an option in the Code Editing | C++ | Performance page. This page also contains a new option to limit the number of concurrent threads used by C++ caches — you can try tuning it to improve responsiveness during the code indexing phase, at the cost of total indexing time.
If ReSharper’s performance is still unsatisfactory, you can use the Third-party code options page to stop ReSharper C++ from indexing specific files and folders.
This page allows you to specify two kinds of filters:
Skipped Code contains files that do not get indexed at all, and is usually the right way to exclude third-party dependencies. Only indexing roots (normally .cpp files) are excluded, so if a .cpp file that is indexed includes some header files, their contents will be indexed regardless of third-party settings (since this is a prerequisite for correct parsing). So in practice, you should be able to just add the directories with third-party libraries to “Skipped code”, and if you include a header from a skipped library into your code, ReSharper will still be able to navigate to it.
Library Code contains files that ReSharper C++ must not modify. Highlightings are disabled inside these files, but they get indexed and ReSharper C++ is aware of symbols inside them. For example, Goto Symbol and auto-import will work for those files.
The File and folders list can only contain files and folders that are a part of the solution. The File masks list allows to match arbitrary paths. Masks are automatically prefixed by **/ and are matched against absolute file paths. If you want to match all files inside a folder, /** would also be required at the end of the mask. So for example, files inside C:/Foo/Bar would be matched by Bar/**, Foo/Bar/**, or C:/Foo/Bar/** (although shorter masks might match unwanted folders too).
Code formatting
EditorConfig offers a convenient way to share code style settings between teammates who use different editors and IDEs. ReSharper 2017.1 supports EditorConfig configuration files out of the box. To learn more about this, refer to the Using EditorConfig help section or watch the introductory video.
A new setting in the General Formatter Style options page (turned off by default) makes ReSharper C++ automatically detect and set the indent size used in a file. This feature becomes particularly handy in solutions where different files have variable indent sizes.
Indenting of preprocessor directives is now supported and controlled via the Indentation | Preprocessor directives indenting formatter option. Code that uses the OpenMP API is one example where this option is crucial for correct formatting:
The list of other formatter options introduced for improved configurability includes:
Indent namespace members.
Break line in simple case statement.
Spaces within/after parentheses in cast expressions.
Place enumerators on new line.
Align multiline chained method calls and binary operators.
Navigation and find usages
The list of small and not-so-small improvements in navigation and find usages includes:
The Find Results window now works asynchronously, meaning that you can work with the results tree while usage search is still in progress.
The Go to Everything and Go to Text popups support inline commands for advanced filtering of search results.
The Find Results window allows you to group results by kind of usage. This ability is very useful if you want to inspect only specific usage scenarios.
Recent Files can delete entries with the Delete key, and both the Recent Files and Recent Edits popups will now show the path of the file, to avoid confusion with similarly named files.
There is a new setting to remember the last search in Go to Everything, Go to Text and other search actions.
ReSharper’s Search & Navigation page adds a new option to open files in the preview tab from everywhere. This option is turned off by default.
ACCU 2017
The ACCU 2017 conference takes place in Bristol April 25-29 and as always has a great lineup of presenters and a lot of interesting talks, including “Functional C++ For Fun And Profit” and “A look at C++ through the glasses of a language tool” by our very own Phil Nash and Anastasia Kazakova. You can watch video recording on the ACCU conference YouTube channel later if you do not attend, but if you do, be sure to stop by the JetBrains booth to say “Hi,” grab a couple of souvenirs or shoot any questions at members of the ReSharper C++ and CLion teams.
That about wraps it up! All in all, 210+ issues have been fixed in the 2016.3 release iteration, and 140+ issues in 2017.1. We’d like to give a big shout-out to everybody who tried Early Access Preview (EAP) ReSharper builds and helped us iron out the bugs and improve the product. As always, please leave us any feedback and report issues either in the issue tracker or on the support forum. Develop with pleasure with ReSharper C++!
This blog post about the C++ ecosystem in 2017 is worth a special mention. Written in January, it overviews nicely the main expectations and trends, and not just about the language. While C++17 is indeed the main topic for this year’s discussions (as well as the features that failed to be included and so postponed for the future), it is also about adopting new standards and libraries, and of course the community including user groups and conferences.
C++17
As C++17 is approved, pending national body comments, there are lots of resources now where you can find the final feature list, explanatory code samples, committee meeting live threads and committee meeting trip reports. This list by Bartlomiej Filipek is quite useful as it provides code samples for each feature, lists the key compilers (GCC, Clang, MSVC) explaining the versions where the feature is supported, and links to various additional articles. It’s very detailed and includes every small change. Continue reading →
![[[nodiscard]] and [[maybe_unused]] attributes](https://d3nmt5vlzunoa1.cloudfront.net/rscpp/files/2017/09/nodiscard_maybe_unused.png)
Please note that the naming rules for getters and setters, which are present in previous versions of ReSharper C++, are now gone. You can use new options in the Generate getters and setters dialog instead to control whether or not to add 
This 
As C++17 is approved, pending national body comments, there are lots of resources now where you can find the final feature list, explanatory code samples, committee meeting live threads and committee meeting trip reports.