What’s New in IntelliJ IDEA 2021.3

IntelliJ IDEA Ultimate now supports a Beta version of our Remote Development workflow. It allows you to connect to a remote machine running IntelliJ IDEA’s backend from anywhere in the world. All the processing happens on that powerful remote machine, and you can work on your project as seamlessly as if it were on your local one. This functionality can be initiated from IntelliJ IDEA’s Welcome screen or from a new application called JetBrains Gateway, which is available in the JetBrains Toolbox App.

What’s more, you can create, prebuild, share, reproduce, hibernate, and manage dev environments with Space – a unified platform for the entire software development pipeline.

Check out this blog post for more details.

IntelliJ IDEA 2021.3 brings a new, faster way to diagnose and fix issues that are causing your IDE to not work properly. If your IDE isn’t working properly, invoke the new Repair IDE... action from the File menu. It will guide you through a sequence of steps to troubleshoot some of the most common problems.

Smart Step Into

When you want to debug an expression with chained method calls and lambdas, the Step Into action gives you the functionality of Smart Step Into by default. It highlights the methods and lambdas you can step into. To use it, click the Step Into button located in the top pane of the Debug tool window or use the F7 shortcut. The IDE will then highlight the places where you can step into the code, and you’ll be able to select the line you want by clicking on it.

Inline stack frames

The debugger can now detect Kotlin inline functions and display inline function calls in the stack trace panel. You can navigate to these calls, and you can also inspect and evaluate the variables of each frame.

As requested, we’ve made it possible to change the font size in all open tabs simultaneously with ⌘+mouse wheel on macOS or Ctrl+mouse wheel on Windows and Linux. To enable this feature, go to Preferences/ Settings | Editor | General, choose Change font size with Command + mouse wheel in, and select All editors. If you select Active editor, the shortcut will change the font size only in the file where you are currently working.

IntelliJ IDEA has a helpful option that allows you to preview the results of intention actions and quick-fixes before applying them to your code. This feature is available in the Intention actions menu. To activate the preview, press F1 on macOS or Ctrl+Q on Windows and Linux.

Since its introduction in v2020.1, we’ve continued working to improve the intention preview. In IntelliJ IDEA 2021.3, it works for more intention actions and quick-fixes in Kotlin, and the “Preview isn't available” message has been replaced with more informative HTML descriptions of the intention actions that aren’t supported. What’s more, for an action that modifies several files, the preview displays part of a possible outcome. This partial outcome should be enough to give you a general idea of what the action will change.

In IntelliJ IDEA 2021.3, tables can be created with ease. Simply invoke the context menu and select Insert | Table. That’s it! You can select the preferred size using the mouse hover action or the keyboard.

The cell width in the table will be adjusted as you type. You can edit the table content using the floating toolbars.

To create a new row, you can use Shift+Enter, and Tab to navigate to the next cell.

Working with editor tabs just got easier. Just click the three dots in the right-hand corner of the tab pane to access all the tab actions.

We’ve introduced the new Bookmarks tool window that is destined to replace a similar instance – Favorites. So from now on, you can simply use the F3 shortcut on macOS or F11 on Windows and Linux to mark your files, folders, and classes as important.

When you add a bookmark, by default IntelliJ IDEA puts it in the node named after your project in the Bookmarks tool window. Every time you add a new bookmark, it will appear at the top of the list inside this node. You can sort your bookmarks by type using the Sort Groups and Bookmarks option in the tool window’s settings. You can also create new nodes and drag and drop items in them.

When searching for actions, Search Everywhere in IntelliJ IDEA is now powered by machine learning by default. We’ve trained an ML-based formula that takes into account:

• The specific user’s action usage history.
• Action usage frequencies across the whole user base.
• The lengths of the search query, the action’s name, and so on.

We hope you find that the ML-based models boost your search quality and return results tailored to your specific needs.

When you search for usages of a method implementation via ⌥F7 on macOS or Alt+F7 on Windows and Linux, the IDE no longer asks whether you want to find usages of the base method in a pop-up. Instead, IntelliJ IDEA will use top-level hierarchy methods as targets for your search by default. If you want to change this behavior, deselect the Search for base method usages checkbox in the Find Usages tool window settings, which you can access by clicking the gear icon.

IntelliJ IDEA 2021.3 addresses some accessibility issues to make working with the screen reader more comfortable. In response to your requests, we’ve disabled the tool window widget pop-up and the quick documentation pop-up that used to appear on mouse hover. We’ve also fixed an issue with calling the Go to Declaration dialog.

In this release, the accessibility support on macOS has also been improved. We’ve resolved several issues with the voiceover focus and made it possible for screen readers to detect the list items in the New Project wizard when you create projects. To minimize distractions while you're coding, we've decreased the number of help tooltips that play sounds.

IntelliJ IDEA now warns you about hazards such as SQL injection and XSS flaws, sensitive data leaks, and insecure deserialization. It also prevents you from passing insecure data to secure methods. These additional warnings are provided by our new Non-safe string is passed to a safe method inspection.

For this inspection to work, you need to annotate strings as @Untainted ( “safe”) or @Tainted (“unsafe”). These annotations will become valid when you add the org.checkerframework.​checker.​tainting.​qual dependency.

We’ve added two inspections that can help you to simplify your code. The first one suggests that you replace collect(toList()) with .toList(). You can use it with Java versions 16 and up. Another inspection prompts you to replace collection.addAll(List.of("x")) with collection.add(x), and map.putAll(Map.of("a", "b")) with map.put("a", "b").

When you introduce a local variable in Java, the settings that are applicable to it no longer appear in a pop-up, which used to cover the code you were writing. Instead, you can access these options by clicking the gear icon next to a variable or by using the ⌥⇧O shortcut on macOS or Alt+Shift+O on Windows.

We’ve also improved the Introduce parameter refactoring. When you invoke this refactoring, with ⌥⌘P on macOS or Ctrl+Alt+P on Windows and Linux, the IDE asks where you want to replace occurrences. After you make this selection, a gear icon will appear, and clicking on it will allow you to configure more settings for the refactoring.

We’ve introduced a new refactoring that lets you extract constants in Kotlin. To use it, put the caret on a string and press ⌥⌘C on macOS or Ctrl+Alt+C on Windows and Linux.

The Possibly blocking call in non-blocking context inspection warns you if you use a coroutine in the wrong context. In this release, the inspection works not only as a warning but also as a context-dependent quick-fix.

What’s more, we’ve made some further improvements. This inspection now covers more cases, and you can customize it, so it works better in your particular environment.

Sometimes it can be difficult to understand the various ways to declare the ranges that Kotlin supports. To make it a little easier, we’ve added inline hints that explain with plain mathematical signs what the words or symbols in the ranges mean. If you don’t need this feature, you can easily disable it by right-clicking on a hint and selecting Disable ‘Ranges’ hints type.

We’ve reworked the layout of the New Project wizard by adding tooltips for all of the fields, so you can easily understand what info they require. The templates section has received an update as well – we've removed some of the unpopular templates and added a new one that lets you create a Compose Web Application.

And finally, the project set up step has become much simpler. You now only need to fill in the basic fields.

The main focus of this release has been Scala 3 support. We've added highlighting, navigation, and autocomplete for end markers. There's now autocomplete for given, using, and export keywords, soft keywords, and the quiet syntax. The TASTy reader can now parse package object, as well as variance and bounds in higher-kinded types. The highlighting of lexer and parser errors is now significantly faster. There are more inspections that are compatible with Scala 3. We've improved the resolve of given imports and supported final top-level members and abstract lazy val.

Many projects that should be compiled for both Scala 2 and Scala 3 are modeled as Scala 3 projects cross-compiled for Scala 2, even though technically they are Scala 2 projects.

Opening such projects as Scala 2 allows the IDE to use the correct Scala version, and is more reliable.

The Scala plugin now supports data flow analysis, which can help you detect programming errors more easily. You can read our recent blog post for more details.

There are tons of different options in the Scala compiler, and very few programmers learn them by heart. Furthermore, those options vary depending on the Scala version in use.

You can now autocomplete the applicable options and even see Quick Documentation for each of them.

IntelliJ IDEA 2021.3 allows you to update your npm packages to the latest version right from the editor! Open your package.json file, place the caret on the package version you want to update, and then press ⌥⏎ on macOS or Alt+Enter on Windows and Linux and select Update ‘package name’ to the latest version. A quick-fix will also be shown when you hover over the package version.

We’ve improved the way code completion works in HTML. Whenever you type a tag name or an abbreviation in the editor, or invoke code completion, IntelliJ IDEA will show you relevant suggestions right away. Previously, it would only show them if you typed < first. Additionally, code completion for character entity references should now work better.

It is now easy to check whether the changes you’ve made worked for your program or caused a regression. To do so, just open two snapshots that you want to compare in the Profiler tool window. In the most recent snapshot, click the diff icon and select the snapshot you’ll use as the baseline. The IDE will display the result in the form of a flame graph, call tree, or method list.

In v2021.2, we added support for Async Profiler 2.0 to the macOS and Linux versions of IntelliJ IDEA. Starting from v2021.3, the Windows version supports Async Profiler 2.0 out of the box as well. This support provides a smoother profiling experience and also improves the way native functions are displayed in snapshots.

This release takes some steps toward improving our Run/Debug configurations, and this time, Maven configurations have received a significant redesign. The key parameters are all grouped on one screen, while additional options are available via Modify options.

If you want to configure the Maven settings for each project in the .mvn/maven.config file, go to Preferences/ Settings | Build, Execution, Deployment | Maven and select Use settings from .mvn/maven.config at the bottom of the screen. Please keep in mind that the settings from this file override the standard Maven UI settings.

We’ve improved the way the settings in Preferences/Settings | Version Control are structured, and we’ve made some of the critical configurations there more discoverable. The Version Control node now serves as the starting point for navigation, with links to all the available settings. If you go to the Git node from there, you’ll notice that we have divided all the settings into sections that account for the most important processes: Commit, Push, and Update. Additionally, the parameters inside these sections are now organized more logically. What’s more, we’ve added a separate node for Directory mappings, and the background operations are now switched on by default. The Background node no longer exists.

Starting from IntelliJ IDEA 2021.3, your IDE shows the difference between commits in a separate Changes tool window located to the left of the editor.

We have a new action that allows you to push only the commits you are confident about and leave the rest for later.

It allows you to push commits up to the one you have selected in the Log tab of the Git tool window. To use it, pick the commit you want to stop at, right-click on it to call the context menu, and select the new Push All up to Here action.

In v2021.3, we’ve introduced support for the new ConPTY API on Windows. It addresses several issues users were having with the old implementation, which was based on winpty, and adds support for 24-bit colors in the terminal.

Our newly added typeahead support in the IntelliJ IDEA terminal predicts text modifications and instantly displays them in light grey. This feature allows you to type in the terminal equally fast on both a local or remote machine.

IntelliJ IDEA’s HTTP client provides basic support for gRPC requests. When you type the GRPC keyword to start your request, the HTTP client offers code completion. Thus, your IDE prompts you about all known gRPC services, unary and server-streaming methods of a particular server, and, most importantly, fields of the request body.

Another new feature allows you to generate a gRPC request in the HTTP client. To do so, just click on the gutter icons in your .proto files.

When testing streaming applications in IntelliJ IDEA, you no longer need to wait for a stream to end because the HTTP client will display the output on the fly. This is now possible because we’ve added support for the following content types: text/event-stream, application/stream+JSON, and application/x-ndjson. You will also be notified when a stream ends.

In the HTTP client, it is possible to redirect output to a custom file or directory. You can use two operators for forced and soft redirects:

• The >> operator always creates a new file, adding an -n suffix to the file name if the requested file name already exists.
• The >>! operator rewrites the file if it already exists.

You can add request identifiers either as comments via @name or as text in the first separator (###). The IDE understands these identifiers and allows you to invoke requests by them from the Services tool window, as well as from the Run Configuration, Run Anything, and Search Everywhere dialogs.

IntelliJ IDEA can detect when your OpenAPI specifications are located in several files and linked via $ref, and it will provide completion.

We’ve made 2 additions to the JetBrains annotation collection. Once you add 'org.jetbrains:annotations:23.0.0' to your project dependencies, you can annotate your classes and methods as @Blocking or @NonBlocking. This will make it possible for the IDE to detect blocking calls in non-blocking contexts, such as Kotlin coroutines or reactive code with Project Reactor, RxJava, and SmallRye Mutiny.

What’s more, the IDE automatically supports the corresponding annotations from Micronaut and SmallRye Mutiny.

IntelliJ IDEA now detects more cases of blocking code in Spring and Java EE, including Spring Data’s JpaRepository and CrudRepository, RestTemplate and JdbcTemplate, Spring Feign interface methods, JPA EntityManager calls, and any methods and classes annotated as @Transactional.

We’ve reworked the Run/Debug Configurations dialog for Spring Boot projects. The design is similar to previously updated configurations for Java. The new interface presents the key settings on one screen and allows you to configure more parameters via Modify Options.

IntelliJ IDEA now provides code completion in additional configuration files (properties or .yaml files) when a spring.config.import key is used to reference another file. It is also better at setting up complex and custom Spring Boot configuration files.

For Spring Boot projects, the IDE now supports code completion and find usages for references to application.yaml from @Value, @Scheduled, and Environment.getProperty().

Starting from v2021.3, you can use all CDI inspections in Kotlin files. Previously these inspections only worked in Java files. Additionally, we’ve added CDI gutter icons in Kotlin files. They allow you to navigate easily to injection points or injection candidates, bean makers, disposer methods, and events.

We’ve added the ability to display an Aggregate view for a range of cells. This is a long-awaited feature that will help you manage your data and spare you from having to write additional queries! This makes the data editor more powerful and easier to use, bringing it a step closer to Excel and Google Spreadsheets.

Select the cell range you want to see the view for, then right-click and select Show Aggregate View.

This release is a logical continuation of the previous one, which introduced the ability to generate a DDL data source based on a real one. Now, this workflow is fully supported. You can:

• Generate a DDL data source from a real one: see the 2021.2 announcement.
• Use the DDL data source to map the real one.
• Compare and synchronize them in both directions.

Just as a reminder, a DDL data source is a virtual data source whose schema is based on a set of SQL scripts. Storing these files in the Version Control System is a way to keep your database under the VCS.

There is a new tab in the data configuration properties, DDL mappings, where you can define which real data source is mapped to each DDL data source.

The new Database Diff window is available from the context menu. It has a better UI and clearly shows in the right-hand pane what result you’ll get after you perform the synchronization.

The legend in the right-hand pane shows what the colors mean for your potential result:

• Green and italic: object will be created.
• Grey: object will be deleted.
• Blue: object will be changed.

The Script preview tab shows the result script, which can be either opened in the new console or run from this dialog. The result of this script is applying changes to make the database on the right (target) a copy of the database on the left (source).

Besides the Script preview tab, there are two more tabs on the bottom pane: Object Properties Diff and DDL Diff. They display the difference between the particular versions of the object in the origin and in the target databases.

We’ve introduced three levels of introspection for Oracle databases:

• Level 1: Names of all supported objects and their signatures, excluding names of index columns and private package variables
• Level 2: Everything except source code
• Level 3: Everything

Introspection is fastest on level 1 and slowest on level 3. Use the context menu to switch the introspection level as appropriate.

The introspection level can be set either for a schema or for the whole database. Schemas inherit their introspection level from the database, but it also can be set independently.

The introspection level is represented by the pill-looking icons located next to the data source icon. The more the pill is filled, the higher the level. A blue icon means that the introspection level is set directly, while a grey one means that it is inherited.

A huge update brought support for UI test automation in Selenium – the visual editor can now help you to maintain existing page object classes. Previously, it was only possible to generate new page object classes, but now you are even able to update the existing page object classes directly without a visual editor. IntelliJ IDEA will detect page object classes automatically and indicate them with a corresponding icon on the gutter panel. By clicking on that gutter panel, the user can open a visual editor and grab new elements to be added to the page object class.

The newest plugin from the Test Automation Kit got a few minor bug fixes, but also a useful feature in multiple data generator settings. Now you can modify the prefix, suffix, and delimiter with a multiline definition.

You can format your Helm templates and be sure of the correct result. We’ve fixed all the related issues, and the formatting is now much more reliable. To see the improvement, go to Code | Reformat code or Reformat file or press ⌥⌘L on macOS or Ctrl+Alt+L on Windows and Linux.

We’ve added highlighting of such block elements as if, else, range, with, and define in Helm templates. This makes it a lot easier to work with code that contains Go templates inclusions.

IntelliJ IDEA now supports automatic code injections of various languages in ConfigMap resources for keys with extensions like .yaml, .json, .properties, and so on. The injected pieces of code are highlighted in green, and it is possible to use our code insight functionality inside them, including code completion, error highlighting, and others.

It is now possible to rerun your latest helm command from the Services tool window. All you have to do is click the new icon in the top right-hand corner. For example, you run the helm lint command, and after it completes, you can click the icon to repeat it.

It is now easy to connect to a Docker daemon from Minikube. In Preferences/ Settings | Build, Execution, Deployment, select the Minikube radio button. In the field next to it, the IDE will automatically display the detected Minikube's docker-daemon environments that you can use for connecting.

Connecting to Docker has become faster because you can simply double-click on the necessary node or use the new shortcut – ⌘Enter on macOS or Ctrl+Enter on Windows and Linux. The Start container action can also be invoked with this shortcut.

IntelliJ IDEA supports Compose V2, which allows you to run Docker Compose commands as docker compose, instead of docker-compose (with a dash).

To activate this option, go to Preferences/Settings | Build, Execution, Deployment | Docker | Tools and tick the Use Compose V2 checkbox.

Image layers allow you to track all the commands that are applied to images. To access them, select an image and go to the Layers tab. From there, when you choose a command, you can click on the Analyze image for more information link on the right-hand side of the screen for more detailed info about the changes applied to each layer.

If you have a preconfigured container that you want to use later, you can save it as an image locally and push it to continue using it remotely when you need it. Go to the Services tool window, right-click on the container, and select Image | Save as a new Image.

IntelliJ IDEA now supports Podman as an alternative way to manage pods, containers, and images. Before using Podman in the IDE, configure a connection yourself.

Once Podman has been installed and configured on your OS, you can connect to it via Preferences/Settings | Build, Execution, Deployment | Docker by selecting the TCP socket radio button and filling in the required fields.

You can now create merge requests and code reviews for your projects in Space. You have 2 different options:

• Click the + icon on the top toolbar of the Code Reviews tool window and select the desired action.
• In the Log tab of the Git tool window, right-click the commit in the list and choose Space | Create merge request or Create code review.

For more details, check out this blog post or refer to the gifs below.

• IntelliJ IDEA now supports Android Studio Arctic Fox, 2020.3.1.
• We’ve added support for Groovy 4, including full-fledged code insight, functioning inspections, and intention actions. Additional features, such as switch expressions and sealed types, are supported as well.