What’s new in ReSharper 2020.3

Source Generators are almost certainly the most talked about feature in the C# compiler. It’s understandable: the ability to create new code right in the compilation process and use it immediately is exciting and could be useful in lots of different situations.

What can ReSharper do here? Well, it can do what it does best and take the generated files into account while performing refactorings, provide code editor features, and help you navigate to the generated code.

Partial methods are now allowed to have out parameters, non-void return types, and any type of accessibility, making them more useful with Source Generators. Source Generators can use the defining declaration of the partial method to customize the behavior of the generated code.

Another cool addition is init-only properties. Such properties can only be set during the initialization of an object. So finally you can use object initializers without exposing the property as mutable!

ReSharper is aware of init-only properties and takes them into account when completing your code, performing generative completion, analyzing whether the property changed anywhere, and offering a quick-fix to make it mutable if you change your mind.

The perfect place to apply init is new record types. These are reference types with value semantics that help you achieve immutability, but this time for the whole object. Again, ReSharper is keeping up with the language, from quick-fixes for choosing your preferred declaration style to basic completion.

Positional records have a compiler-generated Deconstruct() method. ReSharper supports all deconstruction features in such objects. Notice the popup when introducing a variable: it offers you the choice between single variable or a deconstructing declaration. The same choice will be offered when a function accesses a property of a record object.

Moving on from the big things, local functions are now permitted to have attributes (as well as parameters and type parameters in local functions). This is supported by ReSharper’s quick-fixes, including the neat feature of annotating the method as [NotNull] or [CanBeNull] by pressing ! or ?, respectively.

Another useful C# 9 addition is the ability to write top-level programs. No more fighting with Program classes: you can place your entry point code right after the using directives! There is some help available for working with top-level statements as well. There are two rules about top-level statements: they should precede any type or namespace, and only a single file in the project can contain top-level code. Both rules are easy to break when you’re rearranging and copy-pasting code. ReSharper provides quick-fixes to remedy this by moving your top-level code to the top or to another file.

Given that top-level code is also code, there are refactorings for it as well: Extract local variable and Extract method refactorings.

With target-typed new expressions in C# 9 we can omit the type after the new keyword when it can be inferred from the usage context. ReSharper provides full support for the feature including the ability to Find Usages of the constructor and configure preferred syntax style. The latter allows you to use new() syntax when a created type is evident while enforcing an explicit type specification in other cases.

By the way, ReSharper’s new (pun intended) type name hints can help if all the new() in your code gets out of control.

With return type covariance, you’re no longer bound to returning the same type in overriding members as you do in the base class method. There is no longer any need to implement workarounds to return a more specific type.

Pattern matching continues to evolve in the new language version. Matching expressions now allow using relational (<, >, etc.) and logical (not, or, and) patterns, cutting out a lot of the verbosity of the old switch constructs. ReSharper can assist you with analyzing the patterns and rewriting them in the desired style.

Finally, when lambda discard parameters were introduced, we felt it would be nice to add a quick-fix for them.

That’s about it for the major language highlights. There are smaller improvements added to the language that are supported in ReSharper 2020.3 as well. This includes target-typed conditional expressions, static lambdas, extension GetEnumerator methods in foreach, function pointer types, and native integer types.

In Push-to-Hint visibility mode, hints aren't shown by default. They're shown if you press and hold Ctrl (and hidden as soon as you release it) or press Ctrl twice (in which case they remain visible until you press Ctrl twice again).

We’ve provided quite granular settings: you can tell ReSharper which hints should always be enabled, which should be shown on push, and which you don’t really care for. Use the ‘Visibility’ setting for each hint type.

Another thing we’ve worked on are the hints for implicit type casts. Such casts can result in data loss or performance degradation, and ReSharper can now indicate where an implicit cast is happening.

When you Ctrl+Click on a type conversion hint it will take you to the implementation of the implicit conversion.

Inlay hints for XAML, which were already available in the previous version, now also have the usual context menu that allows you to configure how they look.

A group of settings for arranging property patterns: you can tell ReSharper to place a simple pattern on a single line, and also how you prefer long patterns to be wrapped. There’s also a setting to align the property patterns in columns.

Blank lines can now be added around property or event accessors.

For more details about DPA, please see this blog post.

If you’re working on a large code base, every solution-wide operation takes a long time to run. Have you ever found yourself waiting for the whole solution to be reformatted after you’ve changed a couple of files? Well, now you can run the CleanupCode console tool without pointing to the solution file: just specify a set of files or folders. The command line will look like this: cleanupcode.exe [Path to folder] [Path to file] [Path to another file]

Please note that the tool only formats the code – cleanup isn't available in this mode.

One more thing that was missing from our console tools for some time was support for plugins. Well, it’s back! For now it’s only available on Windows. To make use of it, you’ll need to know the ID of the plugin. Go to the JetBrains Marketplace, open the plugin page, go to the Versions tab, click on any version and it will show you the plugin ID. After that, use the -x=[ID] key with the plugin ID when launching InspectCode or CleanupCode and the console tool will automatically download and enable the plugin: cleanupcode.exe -x=[ID] [Path to solution file].

Please note that the plugin has to be compatible with the tool version. Also, plugins are not yet supported if you’re using the .NET Core global tools mechanism to install ReSharper’s command line tools.

Have you ever struggled when searching for text? Maybe for a string in your code, or a comment? Or did a typo in your text prevent you from actually finding anything?

Find Text now performs fuzzy search in addition to exact search, taking possible typos and missing words into account. The results are displayed below the results of the regular substring search, in the Fuzzy section. Hint: it can be very helpful if you are looking for a certain formatted string build in your code.

As is typical for all the WPF-like frameworks, code analysis provides plenty of common code inspections with appropriate quick-fixes for both C# code-behind and .axaml files including “Possible ‘System.NullReferenceException’” and “Class/Property {...} is obsolete: Use {...}”.

In addition to the common WPF inspections, there are a lot of Avalonia-specific inspections, such as “Path to resource is case-sensitive” or “ColumnDefinitions tag can be converted to attribute” inspections with quick-fixes. For the latter, there is a context action on ColumnDefinitions="*,Auto,*" attribute to convert it back into a <Grid.ColumnDefinitions> tag.

We’ve added proper support for “$self", “$parent”, “^”, and “#” syntax in Avalonia bindings, as well as proper validation of indexes in the $parent[] array.

There is extended support for CompiledBinding and the x:CompileBindings extension. ReSharper knows that DataType is required here and prompts you to specify it for bindings in your code.

The “Create from usage” quick-fix is available for all sorts of Avalonia properties.

Avalonia XAML support includes understanding of the CSS-like styling system.

Specifically for top-level statements, we’ve added a <Top-level Entry Point> node in Assembly Explorer. You can double-click or use the context menu navigation on this node to get to actual top level statements in decompiled code.

Private Source Link is now supported. After you navigate to the external sources that require a connection to a private source server, ReSharper will show a notification and let you enter your credentials; unless, of course, you’ve already specified them in Visual Studio’s settings, in which case they will be applied automatically (for GitHub and BitBucket).

• Support for nullable annotations on unconstrained generic types (includes default constraint).
• We’ve implemented a modest update for TypeScript support: ReSharper now supports nullish coalescing and optional chaining.
• We’ve added a new quick-fix that helps you transform a sequential pattern check into a complex pattern-matching check.
• Inside the Change Signature refactoring, we’ve redesigned the tool used to set the default value for the parameter you’re adding – the tool that is opened when you choose ‘Resolve with call tree’. Navigation to code is now available by double-clicking on a node. There’s a new option called Create default parameter that takes you directly into the code to specify the value. Finally, different colors are applied for different fixes selected in the tree. We hope this makes resolving usages easier!