What’s New in IntelliJ IDEA 2021.3

IntelliJ IDEA 2021.3 provides support for remote development (Beta) and introduces a new way to troubleshoot IDE problems with the Repair IDE... action. It also brings debugger updates and the Constant conditions inspection for Kotlin, along with other valuable changes. The following short descriptions explain these and other noteworthy features in more detail.

Key updates

Remote development

Remote development
Beta
Ultimate

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 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.

Troubleshooting IDE issues

Troubleshooting IDE issues

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.

Constant conditions inspection for Kotlin

Constant conditions inspection for Kotlin

We’ve added the new Constant conditions inspection, which helps IntelliJ IDEA report non-trivial conditions and values that are statically known to be always true, false, null, or zero. It works the same way as the similar inspection for Java, and it supports most of the same checks. This new inspection can be found in Preferences/ Settings | Editor | Inspections | Kotlin | Probable bugs.

Debugger updates for Kotlin

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.

Editor

Change font size in all the tabs

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.

Improved intention preview

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.

Improved Markdown support

Improved Markdown support

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.

User Experience

New Bookmarks tool window

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.

Ability to split the Run tool window

Ability to split the Run tool window

In v2021.3 we’ve made it possible to split the Run tool window with tabs. This allows you to run several configurations simultaneously and see all of the results.

To split the window, drag the tab you want to see to the highlighted area inside the Run tool window and drop it there. To unsplit the window again, right-click the top pane and select Unsplit from the context menu.

ML-based search for actions in Search Everywhere

ML-based search for actions in Search Everywhere

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.

Improved Find Usages

Improved Find Usages

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.

Reworked Show Usages

The Show Usages dialog has received several useful new features. We’ve introduced the source code preview per found usage, which you can see by clicking the square icon in the top toolbar pane. Another update lets you change the scope of your search with the new drop-down list located next to the Preview icon. What’s more, the window’s title bar now shows the type of code element you are searching for and the number of usages found.

Another minor yet very convenient update allows you to set the dialog width, which the IDE will retain the next time you invoke it.

Reworked Empty Project and new Multi-Module Project nodes

In v2021.3, you will notice some changes to the nodes in the IntelliJ IDEA Project Wizard.

You can now select the Empty Project node to create a basic project for working with separate files of different types and adding Java and Kotlin classes. The IDE will automatically configure the project so that you can compile it if any Java or Kotlin classes are present.

The new Multi-Module Project node lets you create a project with a complex structure from scratch. Once the project is created, the Project Structure dialog will open, and you’ll be able to add various modules.

Accessibility updates

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.

Java

Inspection for tracking unsafe strings

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.

Other new Java inspections

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").

Improved refactorings

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.

Customizable classpath in Run/Debug Configurations

Customizable classpath in Run/Debug Configurations

Sometimes you may need to define custom classpaths in the Run/Debug Configurations dialog on a per-config basis. Starting from this version, it is possible to do so by selecting Modify options | Modify classpath.

Kotlin

Extract constant refactoring

Extract constant 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.

Improved Possibly blocking call in non-blocking context inspection

Improved Possibly blocking call in non-blocking context inspection

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.

Inline hints for ranges

Inline hints for ranges

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.

Better New Project wizard

Better New Project wizard

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.

Scala

Scala 3 support improvements

Scala 3 support improvements

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 objects, 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 vals.

An option to open Scala 3 / Scala 2 cross-compiled projects as Scala 2

An option to open Scala 3 / Scala 2 cross-compiled projects as Scala 2

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.

Data flow analysis for Scala

Data flow analysis for Scala

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.

Autocomplete for Scala compiler options

Autocomplete for Scala compiler options

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.

Inlay hints for ranges

Inlay hints for ranges

Have you ever wondered whether 1 to 3 is an inclusive or exclusive range? And what about 1 until 3? Or Range(1, 3)? Set your doubts aside – now the answer is clear.

JavaScript

New inspection for updating dependencies

New inspection for updating dependencies
Ultimate

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.

Improved code completion in HTML

Improved code completion in HTML
Ultimate

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.

SSH

Proxy support for SSH connections

This highly-anticipated new feature allows you to specify an HTTP or SOCKS proxy server for your SSH configuration in Preferences/Settings | Tools | SSH Configurations. Under the new HTTP/SOCKS section, you can select the proxy type, enter a hostname and a port, and apply authentication with a username and password, if necessary. It is also possible to sync your SSH proxy settings with the global IDE ones. To do so, select the Use global IDE proxy settings checkbox.

Profiler

Compare .jfr snapshots

Compare .jfr snapshots
Ultimate

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.

Support for Async Profiler 2.0 on Windows
Ultimate

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.

Build tools

Redesigned Maven configurations

Redesigned Maven configurations

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.

Support for .mvn/maven.config

Support for .mvn/maven.config

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.

Version control

Checkout and Rebase onto Current for remote branches

Checkout and Rebase onto Current for remote branches

When you need to check out the selected branch and rebase it on top of a branch that is currently checked out, you use the Checkout and Rebase onto Current action, which was previously available for local branches only. In IntelliJ IDEA 2021.3, you can use it for remote branches as well.

Reorganized VCS 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.

New Changes tool window

New Changes tool window

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.

New Push All up to Here action

New Push All up to Here action

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.

Align Changes Highlighting

Align Changes Highlighting

We’ve added the new Align Changes Highlighting option to the Diff screen settings that can be found under the gear icon. This feature makes the Diff easier to read, especially when there are complex modifications, because it aligns the unchanged lines so that they are displayed next to each other. This helps you see the code that has been added or removed more clearly.

Terminal

ConPTY support on Windows

ConPTY support on Windows

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.

Typeahead support

Typeahead support

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.

Debugger

Evaluate expressions from the debugger

Evaluate expressions from the debugger

In this release, we’ve improved the discoverability of the Evaluate feature. Previously, when users needed to evaluate something, many of them resorted to using watches. They just created a watch and then removed it, instead of using the Evaluate dialog. The Evaluate field is now accessible right in the Debug tool window, making the most convenient way to evaluate expressions more obvious.

Frameworks & Technologies

gRPC requests in the HTTP client
Ultimate

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.

Binary responses in the HTTP client

Binary responses in the HTTP client
Ultimate

The HTTP client can detect images in responses and display previews of them in the response console.

Support for text streams and JSON streams in the HTTP Client
Ultimate

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.

Output redirection to custom file or directory in the HTTP client
Ultimate

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.

Support for HTTP request identifiers
Ultimate

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.

Qute template language support

Qute template language support
Ultimate

Qute is now among the supported template languages. This means that IntelliJ IDEA provides code highlighting, autocompletion, and other useful features to help you develop templates for your Quarkus project.

References resolve and completion from secondary specification files

References resolve and completion from secondary specification files
Ultimate

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

New Blocking and Non-Blocking annotations for reactive code

New Blocking and Non-Blocking annotations for reactive code
Ultimate

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.

Improved blocking code detection in Spring and Java EE

Improved blocking code detection in Spring and Java EE
Ultimate

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.

Revamped Spring Boot Configurations

Revamped Spring Boot Configurations
Ultimate

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.

Improved support for Spring Boot application files

Improved support for Spring Boot application files
Ultimate

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.

References to application.yaml

References to application.yaml
Ultimate

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

Better support for @NamedQuery used from Spring Data repositories

Better support for @NamedQuery used from Spring Data repositories
Ultimate

Query method completion now works for queries declared as @NamedQuery in Spring Data JPA projects. You can also navigate to the definition of a @NamedQuery via the gutter icon.

Kotlin support for Java EE CDI
Ultimate

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.

Improved UML class diagrams
Ultimate

We’ve sped up all the processes for UML class diagrams, both in Java and Kotlin. Diagram opening, switching between categories, zoom, and the undo/redo functionality now all take much less time. Other notable changes include a new grid, member highlighting, and a quick documentation preview pop-up.

If you need to control the appearance of the diagram, use the context menu and select Appearance.

Database tools

Data editor aggregates

Data editor aggregates
Ultimate

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.

Mapping the DDL data source and the real one

Mapping the DDL data source and the real one
Ultimate

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.

Mapping the DDL data source and the real one

New database diff window
Ultimate

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.

Introspection levels

Introspection levels
Oracle
Ultimate

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.

QA tools

Page Object editor

Editing Selenium page objects

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.

Test Data

Test Data

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.

Test Management

Test Run Hierarchy

We implemented support for multilevel test runs. You can now create multiple child test runs for specific functionality domains or types of testing. Each parent test run aggregates the results of the child test runs and provides summary statistics from all sub-related test runs.

Shared steps

If you choose to manage test cases in Markdown files using our “Local TMS” feature, you will be able to easily declare test steps and share them among multiple test cases. Shared steps are declared as a regular Test Case with a unique numeric ID. You can refer to that test case in other test cases and IntelliJ IDEA will substitute those referenced test case steps when generating previews, test runs, or code templates for an automatic test.

Kubernetes

Improved formatting for Helm templates

Improved formatting for Helm templates
Ultimate

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.

Highlighting of block elements in Helm templates

Highlighting of block elements in Helm templates
Ultimate

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.

Language injection in ConfigMap resources

Language injection in ConfigMap resources
Ultimate

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.

Ability to repeat the latest command

Ability to repeat the latest command
Ultimate

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.

Docker

Connection to Docker from Minikube

Connection to Docker from Minikube

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.

Easier connection process

Easier connection process

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.

New Clean up action

New Clean up action

The new Clean up action works just like the prune terminal command. When you right-click on the Networks, Volumes, Containers, or Images node, you can select Clean up, and the IDE will delete the unused objects. You can also apply this action to the Docker root node to prune all the unnecessary objects in one click.

Support for Compose V2

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

Image layers

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.

Save container as image

Save container as image

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.

Registry updates

We’ve added several changes to the Docker registry. First off, the IDE now displays all available registries in separate nodes in the Services tool window. Previously we only had support for the Docker Hub registry. In v2021.3, we’ve added support for GitLab (registry.gitlab.com) and JetBrains Space (<username>.registry.jetbrains.space).

You can expand the registry nodes in the Services tool window, select the necessary image, and pull it to the desired location. If you have several Docker connections, the IDE will ask you where to pull the image. It is possible to push images to any added registry, and in the Push dialog the IDE automatically detects the available namespaces in the given registry and lets you select one from the drop-down list.

Last but not least, you can use image completion for images from the JetBrains Space, GitLab, and Docker Hub registries.

Podman support

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.

Space integration

Create merge requests and create code reviews from the IDE

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.

Mark files as viewed

Mark files as viewed

All the files that you haven’t yet revised when performing a code review will remain marked with blue dots until you open them. This way, you won’t miss any critical changes. If you want to return to the changes later, you can select Mark as Not Viewed from the context menu. This feature also works for GitHub pull requests.

Other

  • 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.