ReSharper Ultimate + Rider 2020.1

Rider

Backend runs on .NET Core runtime

• Say hello to Rider .NET Core edition. The backend finally runs on .NET Core runtime by default on macOS and Linux, instead of the Mono runtime. You will instantly notice:
  • Better performance.
  • A lower memory footprint.
  • NuGet restore is now multithreaded (not single-threaded like on Mono). This means that it is 4x faster if you have a CPU with 4 logic cores, 8x faster if you have a CPU with 8 logic cores.
  • And the demolition of lots of other Mono limitations.

Xamarin Hot Reload

• Now Rider automatically applies changes made in Xamarin Forms XAML to the application under debugging on a device or a simulator, without rebuilding and redeploying the whole application.
• Please note there is a limitation: If a PC/laptop with Rider and an iOS device are not in the same WiFi network, a Hot Reload will not work, even if the iOS device is connected to the PC/laptop through USB.
• Apart from that, Xamarin support gets one important fix: the “Invalid target architecture 'arm64e'” error no longer appears when running Xamarin.iOS projects on an iPhone XS Max device.

Dynamic Program Analysis (DPA)

• Every time you run your project in Rider, DPA starts collecting memory allocation data. Once you close the application, DPA will show you a list of detected problems: closures, and allocations to large and small object heaps. The great thing about it is that you do not need to start any “profiling sessions” and get snapshots. Just work as usual, and all the data will be collected in the background, with almost zero overhead. Testing DPA on a variety of real solutions has demonstrated a slowdown of only 0 to 2 percent. Please note: DPA is available only on Windows, and you do not need a separate license to activate it.

Dataflow analysis of integer values

• This version of Rider introduces a new type of code analysis to track the usage of integer values in your application. This new type of analysis tracks how the values of all int local variables vary, and it verifies the correctness of all common operations on such variables to detect useless or possibly erroneous pieces of code. Namely, it warns you about:
  • Relational/equality operators always giving true or false results.
  • Heuristically unreachable switch cases checking int values.
  • Meaningless arithmetic operations, such as multiplication by 1, addition of 0, etc.
  • Possible int overflows.
  • Possible division by 0.
• To improve the precision of analysis, this release also adds two new JetBrains.Annotations attributes to use with type members and parameters of the int type: [NonNegativeValue] and [ValueRange(from, to)]. These attributes specify how the values of the particular int members can vary in runtime.

Unity support

• Significant improvements in the memory usage and speed of asset indexing. Rider will now index all of your code before looking at your assets, meaning that all productivity features, such as code completion, highlighting, and inspections, are available for use more quickly than before. Asset indexing will continue after the solution has been loaded, while you continue working, and Rider will find usages and even rename inside assets once indexing is complete. Of course, once done, the index is incrementally kept up to date, only looking at newly changed files.
• Asset indexing is now smarter, too. It understands usages of your code in Nested and Variant prefabs, and it shows usages for ScriptableObjects and values of serialized fields.
• Unit testing discovery now works better with Unity projects, with Rider finding all of the Edit mode and Play mode tests in your project automatically.
• Added a new performance inspection, “Prefer jagged arrays to multidimensional arrays”, which demonstrates better performance in hot paths. This is a micro-optimization, so it is only suggested in performance-critical contexts, such as the Update method, or anything called from Update.
• Rider will no longer suggest Boo.Lang.List or System.Diagnostics.Debug in its code completion for Unity projects.
• Tweaked the order of event functions in the Generate dialog to place the most important methods first. And when generating functions from the Alt+Enter menu, they will generate at the right location, too.

C# support

• This release continues to add more and more support for C# 8 language features. Refactored a lot under the hood in C# language support to prepare code analysis and other features, such as refactorings and ReSharper Build, to support nullable reference types (NRT). In Rider 2020.1, code analysis reports compilation warnings related to nullable reference types and provides quick-fixes for most of them.
• There are also several new inspections and quick-fixes:
  • To detect redundant type parameter constraints with respect to nullable reference types.
  • To detect and use async overloads of methods when available instead of sync overloads.
  • To use the nameof expression instead of using the typeof(SomeType).Name construction to get the name of the current type.

Code completion

• Now the code completion popup displays much faster after you begin typing, especially in large solutions.
• Another very handy feature that has landed in this release is that members marked as Obsolete can be hidden in code completion if you don’t want to see them there.
• Last but not least, completing an item from the code completion popup now respects your code style settings.

Reworked Debug window

• Completely reworked the UI for the Debug tool window to make it as clean and uncluttered as possible. When there’s only one debug session running, the tabs layout is simplified, as all tabs are now on one single level. Tab captions take up less space, so there is more room for debugger content. And when there are multiple sessions, one more tab layer is added to separate the sessions.
• At the same time, this release combines the Threads and Frames views. If you don’t need the Threads view at the moment, you can hide it by clicking the “Hide threads view” icon.

Updates in the Debugger engine

• Now you can detach from a process initially started under the debugger without terminating the app.
• Smart Step Into is enabled by default for the Step Into action (Preferences/Settings | Build, Execution, Deployment | Debugger | Stepping | .NET Languages | Always do Smart Step Into).
• The debugger supports the .NET Core x86 runtime.
• The thread name is now displayed in the execution line to help you understand where the application’s execution is right now.
• You can Skip to Here/Cursor after stopping the debug session on an exception.
• Now you have more control of the Debug Output window and can disable service messages in Debug Output.

Easy way to configure editor's severity

• This new feature lets you easily change the editor’s highlighting levels. With just one click from a non-modal popup, you can turn on or off Code Vision, Parameter Hints, Unity Performance Hints, Errors, Warnings, Suggestions, Context actions, and many more elements. Look for the Pencils icon in the bottom right-hand corner of the code editor tab.

Updates to Unit testing

• Several icons have moved from the left-hand toolbar to the top one.
• Now it's possible to filter the unit test tree with text search, by using the new textbox in the top toolbar.
• The statuses "Failed", "Aborted", and "Inconclusive" have been merged into a single “Broken” one by default. If you’d rather keep them separate, click the "Gear" icon on the top toolbar.
• You can use the new advanced Group by functionality in the Unit Test Explorer and Unit Test Session tool windows to create a custom grouping. With the added Duration element, it is now possible to group unit tests based on the time they take to execute.
• You can filter unit tests by the target framework in the Unit Test Session tool window, in the event that you have more than one (which is quite common nowadays) and don’t want to see some of them.
• You can export and import any of your Unit Test Sessions. This allows you to share them with your team, between your computers, or between branches when you change something in the code and want to run/cover the same set of unit tests for both branches. Also, the exported file is fully compatible with ReSharper, so you can share Unit Test Sessions that you have in Rider with colleagues who use ReSharper, and vice versa.

Reactive TFS client hits RTM

• Rider 2019.3 added an experimental TFS client which provided a dramatic speed improvement for the "Checking for changes" action. In the current release cycle, this release continues to put a lot of effort into the client. Finally, the TFS client hits its first release and brings a lot of improvements. Let’s mention the two most significant ones. First, enabling the Version Control Integration now works for TFS workspaces locally created with Visual Studio. This means you no longer need to re-create a local workspace from scratch in Rider. Second, this release greatly boosts the performance of the Delete and Rollback operations.

Code editor updates

• Rider, like all JetBrains IDEs, now uses JetBrains Mono as the default font in all themes.
• One more ReSharper feature that has been missing in Rider until now is finally here: namespaces can be auto-imported when code is pasted from a file in the solution.
• If you edit NuGet-related files manually, you’ll be happy to get assistance from Rider, as it now offers initial support for editing NuGet.Config, packages.config, and *.nuspec files, including code completion, syntax validation, and the quick documentation popup.
• Method separators are now available in C# to visually separate interfaces, classes, methods, and so on.
• The shortcuts Alt+Shift+Up / Down / Right / Left Arrow will execute a block selection in the same way they do in Visual Studio.
• Two pairs of actions, "Move Caret To Code Block Start"/"Move Caret To Code Block End" and "Move Caret To Code Block Start with selection"/"Move Caret To Code Block End with selection", are now supported in C# and follow the same behavior they do in other JetBrains IDEs.
• Documentation tooltips are shown on mouseover for code symbols highlighted as errors.

Extract Class refactoring

• One more highly requested and long-awaited refactoring available in ReSharper has finally arrived in Rider - Extract Class. Wondering why you need this? Imagine you have a class doing work that should be really done by two different classes. Using this refactoring is the safest and most effective way to decompose that complex class into two single-responsibility classes. Extract Class will help you choose methods and fields to move from the old class to the new class. It will also warn of any broken dependencies and accessibility issues, and suggest conflict resolution options.

Updates to Solution Explorer

• The Solution Explorer view introduces two new useful folders that provide you with more information about your project: Implicit references as a subfolder for the Assemblies folder, and MSBuild import targets.
• Added a new feature to the Add References dialog called Recent Assemblies.
• Introduced a simple designer for application settings files (*.settings).
• File properties are available for all files in the Solution Explorer view (in View | Appearance | Details in Tree Views).
• Resx code generation now works better for .NET Standard projects on macOS and Linux.

Updates on code coverage and performance profiling

• To give you more control of the unit test coverage results that you get in Rider, this release added Coverage Filters. To specify them, go to Preferences/Settings | Build, Execution, Deployment | dotCover | Filtering. If you do performance profiling on Linux or macOS, .NET Core applications can finally be profiled in Tracing mode on these operating systems. Also, you can now attach the profiler to .NET Core applications on Linux.

Run configurations and Build

• Added a very handy action: Cancel build.
• There are "Build/Clean Project" tasks for all run configurations. These tasks allow you to select which projects to build or clean before launching a run configuration.
• Support for the UpToDateCheckInput MSBuild property is now available.
• The UI of “Publish to folder” run configurations now supports “ARM” identifiers and any custom “target runtime” identifiers.
• The bundled MSBuild has been updated to 16.5.

Decompiler and the IL Viewer

• Nullable Reference Types (NRT) support is available in the decompiler. Please note this currently only works in declarations but not in the methods’ bodies.
• Support for decompiling the default members of interfaces.
• Support for decompiling tuple component names has been improved.
• "IL viewer" Code Vision is now available in external source files after decompilation.

Version control support

• Code Vision is now able to show the history for a method. This feature is enabled by default instead of VCS Annotate (adjustable in Preferences | Editor | Code Vision | VCS Actions).
• The Git Branches popup gets an explicit search field and a reworked Refresh button.
• Incoming (blue) and outgoing (green) commit indicators have been added to the status bar.
• Check out the new dialog, “Interactively Rebase from Here”.
• The Repositories tool window is now called Git, Subversion, Mercurial, or Perforce, depending on what VCS you’re using.
• The Diff and Merge views now support code highlighting.
• If you don’t have Git on your machine, Rider will offer to download and install it for you.

New goodies for F# developers

• The Send project references to F# Interactive; action is available.
• The evaluation tooltip on mouseover works for more expressions when you are debugging: self-reference qualifiers in methods and types (this.Property), and indexer expressions ("foo".[1]).
• A Type file template has been added.
• Code analyzers now run in parallel.
• Several new quick-fixes for already existing code inspections, e.g. the Make field mutable quick-fix for the FS0005: Field not mutable inspection.
• A couple of new code inspections with appropriate quick-fixes, e.g. the “Redundant Attribute suffix” inspection.
• Two new code intentions: Elif to If/If to Elif and Negate If expression condition.
• Code Vision has a new action Copy Inferred Type, and it no longer shows parent namespaces for types to make the displayed information shorter.
• Extend Selection can select the whole () expression.

Web development

• A new intention for converting to optional chaining and/or nullish coalescing and for inferring parameters from usages.
• The documentation popup can be displayed on mouseover.
• Vuex and Composition API support.
• Running Prettier formatting on save.
• Full file paths in the Go to popup.
• Yarn 2 support for TypeScript projects.

Database support

• Export to Excel.
• Support for the utPLSQL and Tsqlt test frameworks.
• See the results in the code editor (disabled by default).
• New authentication options.
• Shared SSH configuration.
• Better filtering data in MongoDB.

Other features and improvements

• Support for WIX (Windows Installer XML Toolset) projects finally comes to Rider.
• A new plugin that supports the Godot game engine is available for Rider 2020.1+. It is open-sourced on GitHub.
• C# code style settings are now searchable.
• You can have Rider use the same machine-wide (global) settings file as ReSharper in order to synchronize settings for both tools (adjust this behavior with File | Settings | Tools | ReSharper | Synchronize machine-wide Rider and ReSharper settings).
• Code formatting brings new settings that cover the trailing comma for C# Code Styles. They can be found under Preferences | Editor | Code Style | C# | Syntax Style | Trailing comma, and they are also compatible with the StyleCop SA1413 inspection (except in a very few corner cases).
• The new Zen Mode combines Distraction Free Mode and Full-Screen Mode.
• Split the Terminal tool window vertically or horizontally if you want to run terminal sessions side by side. You can invoke the context menu from the Terminal to create, navigate, and close a split terminal session.
• There are a lot of improvements in the HTTP Client. You can autocomplete URLs and navigate to the related endpoints right from the HTTP request files; you can generate HTTP requests from the Endpoints view; and the HTTP client now correctly autocompletes path variables.
• A unified IntelliJ Light theme is now available for all operating systems.
• The top window border on Windows 10 now looks much better in borderless mode.

ReSharper

Dataflow analysis of integer values in C#

• This version of ReSharper introduces a new type of C# code analysis to track the usage of integer values in your application. This new type of analysis tracks how the values of all int local variables vary, and it verifies the correctness of all common operations on such variables to detect useless or possibly erroneous pieces of code. Namely, it warns you about:
  • Relational/equality operators always giving true or false results.
  • Heuristically unreachable switch cases checking int values.
  • Meaningless arithmetic operations, such as multiplication by 1, addition of 0, etc.
  • Possible int overflows.
  • Possible division by 0.
• To improve the precision of analysis, this release also added two new JetBrains.Annotations attributes to use with type members and parameters of the int type: [NonNegativeValue] and [ValueRange(from, to)]. These attributes specify how the values of the particular int members can vary in runtime.

C# support

• This release continues to add more and more support for C# 8 language features. It's refactored a lot under the hood in C# language support to prepare code analysis and other features, such as refactorings and ReSharper Build, to support nullable reference types (NRT). In ReSharper 2020.1, code analysis reports compilation warnings related to nullable reference types and provides quick-fixes for most of them.
• There are also several new inspections and quick-fixes:
  • To detect redundant type parameter constraints with respect to nullable reference types.
  • To detect and use async overloads of methods when available instead of sync overloads.
  • To use the nameof expression instead of using the typeof(SomeType).Name construction to get the name of the current type.

Performance news

• This release has tons of changes to the architecture of ReSharper that bring us closer and closer to the goal of running all the core ReSharper features out of the Visual Studio process. All these modifications took place under the hood, so you won’t notice any changes in the UI/UX in the ReSharper 2020.1 release build.

Navigation updates

• This update brings several small but useful features to Navigation, and they benefit both those who primarily use the mouse and those who primarily use the keyboard to interact with ReSharper:
  • You can now middle-click (click your mouse’s scroll button) to Go to Declaration.
  • Pressing Ctrl+Enter in the result list of Go to File highlights the file in the Solution Explorer window.
  • You can now use a full path in Go To File / Go To Everything to find files.

Improved XAML support

• v2020.1 makes a lot of improvements and fixes to XAML support that cover WPF, Xamarin.Forms, UWP, and Avalonia XAMLs. It provides much better support for data context inference and symbol resolution in bindings:
  • When d:BindingContext is used
  • In Picker.ItemDisplay in Xamarin.Forms
  • RelativeSource binding in Xamarin.Forms
  • Template binding for the ScrollViewer control
  • When ItemsSource is used as a nested element
• In TreeView.ItemContainerStyle
  • In UWP projects this release adds support for:
  • Conditional XAML markup
  • CustomResource binding
• Additional fixes include support for:
  • Using the Uniform Resource Name (URN) in a definition of a custom XML namespaces schema
  • Putting a slash symbol in a resource name
  • x:Static directives for Avalonia

Updates to Unit Testing

• Starting with ReSharper 2020.1, you can export and import any of your Unit Test Sessions. This allows you to share them with your team, between your computers, or between branches when you change something in the code and want to run/cover the same set of unit tests for both branches.
• Also, Unit Test Sessions that have already been created are preserved after upgrading to a new major ReSharper version, which is handy if you don’t want to lose opened and locked sessions.

Comments in Localization Manager

• There are new rows on the grid for Comments. You can now leave a comment (or edit an existing one) for any value that comes from resource files right inside the grid. You can also export and import these comments. If you don’t use comments, or if you don’t need them right now, you can hide them by clicking the “Show/Hide comments” icon.
• Apart from that, this release implements several performance fixes that make the grid faster to load and filter, eliminate some UI freezes, and make scrolling smoother.
• It’s also worth mentioning that there are quite a few UX improvements:
  • Improved support for right-to-left languages
  • More precise navigation to specific rows from the text editor and refactoring dialogs
  • Enhanced code completion and validation in the dialogs

Code formatting

• Code formatting brings new settings for C# Code Styles that cover the trailing comma. They can be found under ReSharper | Options | Code Editing | C# | Code Style | Trailing comma, and they are also compatible with the StyleCop SA1413 inspection except in a very few corner cases.

ReSharper C++

C++20

• Using enum - ReSharper C++ 2020.1 adds support for using enum declarations, which let you bring specific enumerators from a scoped enumeration into the local scope. A new refactoring, Introduce Using Enum, is available to help you add using enum declarations to existing code.
• C++20's Concepts - For C++20's Concepts, ReSharper C++ supports the new syntax for constrained type placeholders and abbreviated function templates. Improved error messages about unsatisfied constraints help you understand what went wrong during template substitution.
• Template syntax for lambdas - ReSharper C++ also suggests a quick-fix for using template syntax for lambdas when doing so helps you avoid errors or unify your use of lambdas and functions.

Unreal Engine

• ReSharper C++ 2020.1 improves the Rename refactoring in Unreal Engine projects. Now it updates the corresponding *.generated.h include directive and related files with the A, F, E, T, S, and U prefixes.
• When ReSharper C++ detects an Unreal Engine project, it tweaks the default settings to stop suggesting Use auto to better align with the Unreal Engine guidelines. Also, ReSharper C++ 2020.1 includes updated naming rules for console variables and log categories. You can now navigate to namespaces that contain an enumeration in the Unreal Engine style from Search Everywhere/Go to.
• Finally, ReSharper C++ now also supports USF files with virtual file paths and SpatialOS GDK.

HLSL (Experimental)

• ReSharper C++ 2020.1 now provides initial support for HLSL, the High-Level Shading Language. ReSharper C++ highlights HLSL code according to your default color scheme and displays inlay hints and tooltips for code elements with type information and documentation. You can also search for and quickly navigate to structs, functions, or parameters in your entire solution, referenced files, and standard libraries. And to perfect the HLSL experience, ReSharper C++ offers you smart code completion, auto-inserting matching delimiters, and more.

Code analysis

• Several new inspections are available for the following issues, with corresponding quick-fixes that help you resolve them:
  • Unused lambda capture.
  • Lambda can be rewritten to use explicit template parameters.
  • Functional-style cast used instead of a C++ cast.
  • reinterpret_cast used instead of a static_cast when casting to void*.
• Two more features help you adopt the C++17 maybe_unused attribute:
  • A quick-fix to add [[maybe_unused]] to an unused parameter or variable.
  • A context action to replace UNREFERENCED_PARAMETER and Q_UNUSED annotations with [[maybe_unused]].
• The bundled Clang-Tidy binary has been updated to Clang 10, adding more than 70 new checks and compiler diagnostics from the latest LLVM release.

Code completion

• The completion list now suggests label names, standard C++ attributes, the new std::forward postfix template, and arguments for calls to a base function. Additionally, ReSharper C++ now provides code completion in macro bodies.

Coding assistance

• Two well-known features from ReSharper for .NET have finally come to ReSharper C++:
  • Rearrange Code quickly moves code elements around, expands or shrinks the current scope, and more.
  • Complete Statement inserts the required syntax elements to finish the current statement and puts the caret in the right place.
• With improved typing assistance, you can now select any piece of code and type a parenthesis, brace, bracket, or quote to surround the selection with the corresponding characters. The code readability helpers - parameter name hints and type hints - are now available in dependent code.
• The new Document edit action, bound to Ctrl+/ by default, lets you quickly generate a documentation comment for the nearby code element instead of using the context action.

Enum refactorings

• ReSharper C++ 2020.1 introduces two new refactorings to help you upgrade your enum usage:
  • Convert to Scoped Enum converts a C-style enumeration declaration into a C++11 scoped enumeration.
  • Introduce Using Enum adds a C++20 using enum declaration and shortens enumerator references to make your code easier to read.

Navigation

• Code navigation features have been extended to be even handier:
  • Go to Declaration is available on identifiers inside comments.
  • Search Everywhere/Go to includes two new filter categories: concepts and namespaces. Type “/” in the search box to see all the available filters.
  • You can now middle-click (click your mouse’s scroll button) to Go to Declaration.
• In the File Structure window, the icons now have indicators for class member accessibility, inheritance, and virtual/static/pure specifiers.

Sorting of include directives

• ReSharper C++ 2019.3 allowed you to sort #include directives, rearrange existing groups, and create new ones separated by blank lines. ReSharper C++ 2020.1 adds two new settings to make this action even more configurable:
  • Case-sensitive sort.
  • Group headers by directory.
• And it's now possible to import the sorting settings from a .clang-format file if Read code style from .clang-format style is checked on the ReSharper | Options | Code Editing | General Formatter Settings page.

Other changes

• ReSharper C++ 2020.1 comes with several other noteworthy changes:
  • Generate dialogs provide an option to mark the generated getters and constructors with the C++17 [[nodiscard]] attribute.
  • Generate mock functions support the MOCK_METHOD macro introduced in GTest 1.10.
  • The new setting Use named pipes to communicate with child processes allows you to fix unit tests that are misbehaving because of security software.

dotTrace

Next Important Call

• Now, you can navigate through Call Tree using the Next Important Call action. Press Ctrl+Shift+Right and dotTrace will navigate you to a node that is most relevant for further analysis (for example, a node with high own execution time).

dotPeek

Support for Nullable Reference Types

• This release brings better support for C# language features:
  • Support for nullable reference types (NRT) has come to the decompiler. Please note that this only works in declarations, not in the bodies of methods.
  • Added support for decompiling the default members of interfaces and Auto-Implemented Property Field-Targeted attributes.
  • Improved support for decompiling tuple component names.