What’s New in IntelliJ IDEA 2022.1

We reworked the New Project wizard interface to streamline creating new projects. You can quickly launch an empty project; use the pre-configured options for Java, Kotlin, Groovy, and JavaScript; or use generators if you have projects that are more complex.

The updated Maven Archetype project generator in the New Project wizard introduces search-as-you-type functionality when browsing archetypes, the ability to manage an archetype catalog during module creation, and the ability to input required properties by archetype.

We've implemented improved Code Vision inlay hints that provide you with instant insights about your code right in the editor. The list of displayed metrics now includes inheritors, usages, code authors, and related problems. The metrics are all enabled by default now and can be modified in Inlay Hints settings. These settings have also been updated and given a new configuration UI.

You can evenly distribute the working space among editor tabs so that they are all the same width. To set this up, go to Settings / Preferences | Advanced Settings | Editor Tabs | Equalize proportions in nested splits.

When working with Markdown files that contain instructions with commands to execute, you can run those commands directly from the file using the run icons in the gutter.

With the new Copy code snippet in Markdown blocks, you can effortlessly copy contents to the clipboard with a single click.

The redesigned Markdown Editor Floating Toolbar now offers list creation functionality and a dropdown menu that allows you to select header styles. It is customizable, so you can fill it with the options you need.

For formatting consistency in the code, the Add a space at line comment start option has been augmented with an Enforce on reformat checkbox that is enabled automatically. It is available by default for Java, Kotlin, and Groovy, and only modifies line comments that start with alphanumeric symbols.

The command-line formatter supports a dry run mode to validate project files. If a file needs formatting, it will exit with a non-zero status.

IntelliJ IDEA 2022.1 supports new features from Java 18, which was released in March 2022. The IDE now supports code snippets, the changes to pattern matching for switch expressions, and more. For details, refer to this blog post.

The Java decompiler is now more compatible with the Java 17 release. It supports modern language constructors, such as sealed types and pattern matching, features better switch over string decompilation, provides type annotations, and detects common constants.

We have added support for the new features introduced in JUnit 5.7, including support for the @EnabledIf/DisabledIf, @NullSource/EmptySource, and @TempDir annotations.

IntelliJ IDEA 2022.1 supports Kotlin 1.6.20, so the latest language features, such as support for parallel compilation, a prototype of context receivers, and better code sharing across all Kotlin targets, are now available in the IDE. Learn more about the new Kotlin updates in this blog post.

Optimizing package indexes significantly increased the IDE speed when performing code completion, highlighting, and operations related to reference search. The number and scope of re-indexing cases happening after the code changes also decreased.

We’ve introduced some useful improvements and updates for the Smart Step Into functionality while debugging Kotlin projects. We’ve also addressed a number of issues with breakpoints.

To ensure better Kotlin code coverage, the Kover plugin has been integrated with IntelliJ IDEA.

IntelliJ IDEA Ultimate now supports Go microservices, providing features like URL path references, endpoints, Search Everywhere, and gutter icons. The features are available after installing the Go plugin, and they currently work only with standard library functions. More details here.

When working with Spring Data MongoDB, IntelliJ IDEA now highlights JSON queries, completes operators and document fields, and provides navigation to the Database tool window from mapped entities.

There’s a new intention action for .proto files which adds missing import statements for unresolved message references. After adding the missing import statements, the IDE provides completion suggestions for message references.

With IntelliJ IDEA Ultimate, you can now run requests and get completion for service and method names directly from a running server instance. The project does not need to contain .proto files, but the server should support gRPC reflection.

The Helidon framework is now better supported in IntelliJ IDEA Ultimate. The IDE now provides config key completion in properties files and .yaml files, and it supports the Go to Declaration and Quick Doc actions.

We’ve introduced a progress bar for Gradle processes like downloading dependencies and importing artifacts. It allows you to track what exactly is happening with the files and estimate when the process will be complete.

We’ve added experimental functionality to the Maven compiler plugin. It now allows you to set specific language levels separately for production and test sources. You can enable this option in Preferences/Settings | Build, Execution, Deployment | Build Tools | Maven | Importing.

We’ve updated the Code Vision functionality so that IntelliJ IDEA can now instantly provide you with information about code authorship based on the VCS history. Code Author inlay hints are enabled by default in Preferences / Settings | Editor | General | Inlay Hints | Code Vision.

We’ve improved the functionality of Annotate with Git Blame to make investigating introduced changes easier. The IDE highlights the difference between lines right in the editor when you hover over an annotation and opens the Git Log tool window when you click on it.

The Commit Details now includes information about GPG signatures and the build status. Previously, this data was shown only as a column in the Git log.

The new UI for the Git File History tool window is now independent from the indexing process. The data is represented with a new interface, even if the Log index is off.

It’s now easier to work with suggested changes in IntelliJ IDEA, as you can now apply or commit changes locally in the IDE.

IntelliJ IDEA 2022.1 now allows specifying different external diff and merge tools based on the file type. To configure them, go to Settings / Preferences | Tools | Diff & Merge | External Diff Tools.

In the Frames view of the Debugger tool window, we removed the Drop Frame action from the toolbar and instead made it available with an inline Reset Frame icon.

To maximize the usable space in the Debugger tool window, the tab labels are now hidden by default. To make them visible again or to customize their location, use the Show Tab Labels option in the Layout Settings.

The Selenium UI Testing plugin got a huge improvement for its Page Object Editor. We’ve optimized the workflow and redesigned the UI to ensure that fewer distracting elements appear. You can instantly add page elements from the web page to the code on the fly, and then continue editing without leaving the Page Object Editor. You can also choose which selector type to use when adding a new page element to the code.

The new Page Object wizard allows you to choose the language and test automation framework when creating a new page object class. We also made the wizard available at all points in your code where you have a Selenium library dependency. If you want to try out our automatic page object generation with different frameworks and customized templates without creating a new file, there is a special playground mode available via Tools | Open Selenium Page Object Playground.

Modifying resources loaded from the cluster can now be done from the editor tab.

You can manually configure a path to kubectl if it is not in the standard location. To set your custom path, go to Settings/Preferences | Build, Execution, Deployment | Kubernetes | Path to kubectl executable.

Port forwarding functionality for pods is now available. To forward ports, you can either use the icon on the toolbar or choose the context menu item.

There is a new Describe Resource action for all resources in the Services view. You can call it from the context menu or use the toolbar button.

Cluster events are now displayed in a separate node in the Services view, providing data about recent events in the system. To see events for a specific pod, call Describe Resource on it and look for the Events section in the action results.

We’ve introduced limited editor support for werf.yaml and related Helm template files, including code completion functionality, inspections, quick-fix suggestions, refactoring / renaming for .Values.werf.image.*, and validation of some fields like boolean and int.

Support for Docker Compose targets is now available. For example, to run a Spring Boot application on a Compose target, go to the run configuration, create a Compose target via Manage targets, and run the application.

Remote development now features a Backend Control Center widget, which shows CPU load, memory, disk capacity, and other parameters you may need to monitor the backend status.

A new security setting now lets you use SSH key forwarding to authenticate access to git-repositories from your remote machine. Alternatively, you can use the SSH-agent helper to do this.

You can now specify the download path and exact locations for the IDE backend on your remote machine.

You can now select multiple tables and copy them to another schema. Select the tables and press F5 to open the export dialog. When exporting a single table, you can map the columns, see the DDL of the new table, and change it.

The IDE supports cross-DBMS export, which means the target schema can belong to any database from your project. Learn more about it in this blog post.

You can now edit the results in MongoDB collections just as easily as in relational databases. You can also edit result sets obtained via .find(). This will work even if any cursor methods that modify the result, like sort() or limit(), were executed after .find().

The logic for canceling running statements was updated. It’s now clearer that the request is being canceled, and we no longer deactivate data sources without a warning. For more information, read this blog post.

You can now stop the process of creating a connection without deactivating the data source. If you click the Cancel button while the connection is being created, it will be stopped and a ‘Connection canceled’ message will display. Read more about this update in this blog post.

Thanks to the built-in support for React, all of the key features should have already been working in your Next.js projects. IntelliJ IDEA 2022.1 adds support for some framework-specific things, such as pages. The IDE will resolve paths used in the href property of your Link components, as well as in forms and other tags. Code completion, navigation, and refactorings will work, too.

In this release, we’ve added proper integration with Volta, a JavaScript tool manager. IntelliJ IDEA 2022.1 will automatically recognize Yarn and npm installed using Volta.

It is now possible to autocomplete extension methods. Also, the editor offers to import extension methods and given instances automatically. New inspections for the infix modifier and @targetName annotation can help you maintain a consistent code style. We’ve significantly improved the performance of the .tasty reader, so indexing Scala 3 libraries is now up to twice as fast.

Configuring a new Scala project just got easier. With the updated New Project wizard, you can select a project JDK, desired build system, and Scala version in a single step.

Most things in Scala are aliases, including String, Seq, List, Set, and Map. This affects syntax highlighting, GoTo, Quick Documentation, Quick Definition, Find Usages, Optimize Imports, and other IDE features, because they act on aliases rather than actual definitions. To improve the user experience, the editor now treats aliases in the standard library as transparent exports, so that, for example, List implies scala.collection.immutable.List rather than scala.List.

Previously, the detection of unused declarations was limited to private bindings. Now the Unused declaration inspection supports public bindings introduced by classes, methods, variables, parameters, and so on.

When reviewing code changes in the IDE, you can now choose when to post a code review comment.

• Post Now immediately posts the comment in the code review and notifies the author and other code review participants immediately.
• Save as Draft batches all comments, and sends them in one go when you approve changes or wait for a response.

For more details, check out this blog post.

We’ve improved the code review user interface by showing applicable keyboard shortcuts. When posting a code review comment, you can use Enter to add a new line. Ctrl+Enter will save or post the comment.