We have introduced a large number of major upgrades to remote development in IntelliJ IDEA 2022.2 to make your experience more stable and feature-rich. Newly released updates bring various quality improvements. Connect your laptop via SSH to IntelliJ IDEA installed on a remote server and get a fluid developer experience. If you’re using JetBrains Space to orchestrate the backends efficiently with the new version, you can manage your dev environments directly from IntelliJ IDEA. Learn more in this blog post.
IntelliJ IDEA 2022.2 now fully supports Spring 6 and Spring Boot 3 features,
@AutoConfiguration classes and
@ConfigurationProperties classes with the new constructor-binding syntax
@ConstructorBinding. Do not forget to update the IDE if
you want to try Spring 6 or switch your projects to this new version.
To make it easier to run and debug single files without having a dedicated run configuration, we’ve introduced the new Run Current File functionality available from the Run/Debug widget. With its help, you can run and debug the file you currently have open, and the IDE will automatically use the run configuration type best suited for this file.
There’s a new keyboard shortcut that changes the font size everywhere in the editor. To increase the font size, press Alt+Shift+Period. To decrease it, press Alt+Shift+Comma. Also, there is now a font size indicator showing the current font size along with the option to revert it back to the default.
For macOS, we’ve introduced the ability to organize your working space by merging all opened project windows into one, turning each window into its own tab. To perform this action go to Window | Merge All Project Windows.
You can now configure the way inspections appear in the editor without changing their severity level. When you want to change the inspection highlighting style, you can do so using the new Highlighting in editor drop-down menu, which conveniently shows all available options.
The Cloning repository progress bar now appears on the IDE’s Welcome screen and is shown right in the projects list, which makes it clearer and easier to use.
The Add Mnemonic Bookmark dialog has been upgraded with a Description field so that you can now add an optional description to your bookmark right away.
It’s now possible to disable automatic block comment closure when pressing Enter. To do so, go to Settings / Preferences | Editor | Smart Keys and uncheck the Close block comment checkbox in the Enter section.
You can now access Code Completion Settings and configure your preferences right from the kebab (three vertical dots) menu button in the code completion popup.
When a file is explicitly associated with plain text by mistake, IntelliJ IDEA now notifies you about the erroneous file type association and suggests resetting it right from the editor, without you having to do it manually in Settings / Preferences.
It’s now possible to easily generate tables of contents in Markdown files based on
the document headers. This new action is available from the Insert and
Generate popup menus that you can invoke via the Alt+Insert
shortcut or with a right click. The IDE will insert a table of contents at the current
caret position and enclose it with
<!-- TOC --> tags, so that you can
update it later by calling the same menu.
We’ve implemented a range of changes to Java inspections to help you track down potential
bugs and simplify code. For example, the Standard ‘Charset’ object can be used
inspection has been improved so it now recognizes
.toString(). The IDE can now warn you when pattern variables hide fields,
and it catches meaningless
Objects.requireNonNullElse calls. A number of
JUnit-related Java inspections were converted to JVM inspections, so they are now also
available in Kotlin. Also, code completion now suggests .class literals where
To learn more about other Java-related improvements, read our blog post.
We’ve added support for the features introduced in Kotlin 1.7.0, the latest language version. The IDE now properly renders definitely non-nullable types and provides you with a helpful inspection for opt-in requirements.
We’ve integrated the Kotlin debugger with the Data Flow Analysis functionality so that it now displays DFA hints showing which conditions are true and which branches will be executed. Previously, this integration was available for Java only, but is now also supported for Kotlin.
Starting from v2022.2, the bundled Kotlin compiler is no longer used with the IntelliJ IDEA native builder. Both local and CI builds now run with the version of the Kotlin compiler declared in the project settings. This change eliminates inconsistencies between local and CI builds that were previously appearing due to the mismatch of the bundled compiler version and the version defined in the project's build file. Learn more in this blog post.
Our latest work to optimize indexes has positively impacted the IDE’s speed and performance for code highlighting, completion, and Find Usages.
As of v2022.2, IntelliJ IDEA can read match types from .tasty files,
properly parse them, resolve type variables, use them as type arguments, support
inspections, and show types as text. On top of that, we’ve added support for
polymorphic function types
type-level compiler intrinsics
? as a wildcard together with
_ in Scala 2.13.9
and 2.12.16. Copy-pasted code is also now properly indented.
IntelliJ IDEA 2022.2 now warns you when the
return keyword is being used inside an
anonymous function to jump out of the function without executing all the code inside
it. This is usually not an intended usage, and can lead to leaky implementation and
hidden performance costs. There’s a new warning triggered when a private or
class parameter shadows a superclass variable. Additionally, an error is
displayed when you try to override a variable in a way that is forbidden by the
compiler. These new warnings can be configured to be displayed if their respective
compiler options (
-Xlint:private-shadow) are present.
If you have a line of code that is excessively long because it contains a list of arguments or elements in a collection, you can now use the Put arguments on separate lines action from the popup menu to quickly split the list into multiple lines. The opposite is also possible – if you think a multi-line list is short enough, you can use the Put arguments on one line action to make them one line.
Compiler-based highlighting has been tuned for better resource usage. The IDE now respects the file highlighting settings defined by the user. Compilation is now triggered in fewer cases and uses fewer background threads. The compilation scope has been reduced to the relevant module and source scope.
The Safe Delete action removes an element from the definition and all of its calls. This action now also works for type parameters.
We’ve added support for Groovy-Integrated Queries (GINQ). The IDE now provides syntax highlighting, code completion, and inspections for this feature of Groovy 4.
IntelliJ IDEA 2022.2 can now help you import trusted SSL certificates from system trust stores. It will automatically use the custom certificates specific to your enterprise environment. No extra actions are required from you, as everything should work right out of the box.
We’ve upgraded the IntelliJ Profiler, making it easier to collect snapshots. Now, when you start profiling, the CPU and Heap Memory live charts appear side by side with the console. As a result, you can see how your application is performing while also collecting many snapshots from the same application within the desired profiling period.
Kotlin inline functions are now shown along with others in the Flame Graph, the Call Tree, and the Method List, allowing you to see their CPU time and optimize it, if needed. This feature currently works on Linux and macOS and is only available for the Start profiling option. We’re working to add Windows support for it, and we will also soon be adding it to Attach mode.
Spring Framework 6 lets you define an HTTP client as a Java interface with annotated methods. IntelliJ IDEA 2022.2 provides URL completion, navigation, and integration with the HTTP client for such interfaces.
IntelliJ IDEA Ultimate now provides URL completion, Search Everywhere functionality, and Find Usages hints for Spring Cloud Gateway URLs. You can easily generate an HTTP request or find all gateway routes by using the Endpoints tool window.
IntelliJ IDEA 2022.2 automatically highlights JSON/XML bodies in tests with popular Java APIs such as Spring WebTestClient, RestAssured, WireMock, and MockServer. As a result, these data fragments feature better readability and are easier to edit. You can also use URL completion and navigate to declaration in these places in your tests.
IntelliJ IDEA 2022.2 can now help you with debugging GraalVM native image binaries. You can attach the debugger to any GraalVM-based executable or start your application with the debugger attached. The corresponding run configuration will be created automatically for Maven/Gradle projects. This integration is experimental and requires the dev build of GraalVM and this plugin to be installed.
You can now easily navigate to generated code from .proto files and back. Make sure both the gRPC and the Protocol Buffers plugins are enabled.
IntelliJ IDEA 2022.2 now recognizes CLI commands declared with the Spring Shell library and checks their correctness.
IntelliJ IDEA now correctly supports JAX-RS common web service URL patterns
@ApplicationPath and sub-resources in URL completion,
navigation, and Find Usages.
IntelliJ IDEA Ultimate 2022.2 supports WebSocket connections, allowing you to create requests, and send and receive messages.
IntelliJ IDEA Ultimate can now send GraphQL queries over HTTP and WebSocket protocols out of the box. For http:// and https:// simple HTTP requests are used, while ws:// and wss:// are delegated to the WebSocket executor.
We’ve implemented a couple of UI/UX improvements to the HTTP client. Firstly, we introduced a convenient way to select a run environment using an icon in the gutter. To enable it, choose the Select Environment Before Run option from the Run with combobox. Secondly, we improved the Response view by adding a progress bar, which allows you to track the downloading process.
JSON, YAML, and .properties files now feature automatically inserted web references inside values that start with http:// and https://. You can easily open these links in a web browser with one click, or you can generate a request in the HTTP client from the Context Actions menu (Alt+Enter).
IntelliJ IDEA 2022.2 now provides references and supports folding for message attributes in Bean Validation annotations in Java and Kotlin. You can use completion for message keys or navigate to their declarations in the i18n ValidationMessages.properties files.
We have reworked the AWS CloudFormation plugin by updating metadata schemas and improving property completion. You can install the updated version of the plugin from JetBrains Marketplace.
IntelliJ IDEA now supports all of the features in Jakarta Persistence 3.1, including the new JPQL syntax, functions, and types, and it provides language highlighting and code completion for them.
IntelliJ IDEA 2022.2 introduces image completion for the Testcontainers API where you can find all available Docker images and their versions. Click on the reference to open the corresponding Docker Hub URL in your web browser.
It is now possible to easily copy images from one Docker daemon to another using the new Copy Docker Image action, which saves the image to a file and then pushes it to the chosen connection.
IntelliJ IDEA 2022.2 now automatically connects to Docker after you restart the IDE. This new setting is enabled by default but can be switched off in Settings / Preferences | Advanced Settings | Docker.
As of v2022.2, IntelliJ IDEA integrates with Colima and Rancher to support more options for establishing connections to a Docker daemon.
The Kubernetes plugin for IntelliJ IDEA 2022.2 provides integration with the Telepresence tool in order to intercept HTTP requests from services in the Kubernetes cluster and route them to your service running locally. This allows you to debug those services more easily and run only the required subset of services locally.
The web page structure UI has been significantly improved. Now you can comfortably read the most important parts, such as the tag name, the ID, and applied CSS classes, thanks to the text format highlighting.
Now you can easily navigate back to a page element by simply clicking on its icon in the gutter.
When creating a new page object file, the wizard now offers an optional URL field. If the web address is included, the wizard suggests a page object file name based on the link address. Also, the inserted URL is automatically loaded when the Page Object Editor opens.
When adding new page elements to your code, the caret now automatically moves to the end of the added code block, so you can easily navigate it and simply continue editing.
Whenever you type a new non-referenced page object class when working on an existing one, you can fix the unresolved code warning by simply navigating to the warning’s context menu and creating a new page object.
For v2022.2, we’ve enhanced the file importing process by implementing the ability to select several CSV files and import them at once.
The new UI for the Modify dialog has become the default option. Starting with version 2022.2, all of a table’s child objects can be added and edited using this new UI. The old UI will remain available via the context menu.
To ensure that database objects in SQL scripts are resolved more precisely, we’ve implemented two resolve modes: Playground and Script. The first one is the better option if your file is just a set of unconnected queries that are independent of each other and have no particular sequence. The second is better when your queries have sequential logic and should be run as a single script.
We’ve been actively working on support for Angular 14 in IntelliJ IDEA 2022.2. The
most important addition we’ve made in this release is support for Angular standalone
components. IntelliJ IDEA now properly recognizes components, directives, and pipes
IntelliJ IDEA 2022.2 provides better support for Vue 3. For example, it now
understands type narrowing in
v-if/else directives. Also, support
for Pinia, the Vue team’s recommended state management solution that works as
a global store, has been improved. Both completion and resolve now work in Vue
with the Pinia library, and you can navigate to state properties and actions
defined in the store.
IntelliJ IDEA 2022.2 comes bundled with TypeScript 4.7, supporting new language features like moduleSuffixes and ESM in Node.js. It will automatically insert the .js extension to the import statement if the module is set to node16 or nodenext in your tsconfig.json file. Additionally, the IDE supports the typesVersions field in package.json files.