Released: Dec 6, 2023

Mises à jour de 2023.3

Fonctionnalités

Key Highlights

• AI Assistant is out of preview [General Availability] - JetBrains AI Assistant is now generally available with a number of new and improved features to increase your productivity in JetBrains IDEs. The latest updates include enhanced code generation directly within the editor, context-aware AI chat that answers project-related queries without requiring you to copy code, and project-aware AI actions that use extended context to provide more comprehensive results. A new diff viewer makes it easier to identify changes the AI actions have made to your code.
• Full support for Java 21 features - Added full support for the latest Java 21 features. These updates include significant additions such as virtual threads, record patterns, pattern matching for switch expressions, and sequenced collections, along with previews for newly introduced language features such as string templates, scoped values, and more.
• Run to Cursor inlay option in the debugger - Introduced a new Run to Cursor inlay option that allows you to execute up to a specific line of code while debugging. Once your program is suspended, simply hover over the line of code you want to execute up to and click on the Run to Cursor popup.
• Floating toolbar with editing actions - Introduced a floating toolbar that appears next to selected code fragments and provides easy access to editing actions such as Extract, Surround, Reformat, and Comment, as well as context actions. You can use the kebab menu (three vertical dots) to customize the floating toolbar.
• Out-of-the-box Kubernetes development experience - This release bundles the Kubernetes plugin, meaning that all the plugin's features for developing Kubernetes-based applications are now available out of the box. This integration streamlines the workflow for deploying, debugging, and managing Kubernetes clusters directly from the IDE.
• You can use AI Assistant in IntelliJ IDEA as a supplemental feature with a JetBrains AI Service subscription.

User experience

• Option to hide the main toolbar in the default viewing mode - Added an option to hide the main toolbar when using the IDE's default viewing mode, just like in the old UI.
• Default tool window layout option - Improved the ability to save multiple tool window layouts and switch between them. The new Default layout option provides a quick way to revert your workspace's appearance to its default state.
• Color-coded editor tabs by default - To enhance your navigation experience when working simultaneously with a variety of file types in the editor, default color-coding has been introduced for editor tabs, mirroring their appearance in the Project tool window.
• New product icon for Apple macOS - The IntelliJ IDEA icon for macOS has been redesigned to align it with the operating system's standard style guidelines.
• Speed Search available via shortcut - The Speed Search functionality, which allows you to quickly navigate within tool windows and dialogs, is now available via a shortcut. Once the focus is placed on a tree or list, you can easily invoke the search from the tool window's Options menu.

Java

• Inspection for migrating from string concatenation to string templates - Following the release of string templates in Java 21, a new inspection has been implemented to streamline the replacement of concatenated strings. The IDE will now provide a quick-fix suggestion to replace concatenation with the STR template processor.
• Move refactoring for local classes - It's now possible to apply the Move refactoring to local classes, allowing you to relocate them within your codebase.
• Reworked code completion for static methods - Enhanced code completion for utility methods, which are often static and located in other classes. When the target class is the first parameter, static methods are now treated the same as instance methods, making relevant completion suggestions more discoverable. To keep the code completion popup uncluttered and make the suggestions for utility methods easier to find, they have been collected into a list that appears when you invoke code completion a second time.
• Improved inspections for constant conditional expressions - IntelliJ IDEA's code analysis now covers more scenarios when identifying and highlighting potential errors in conditional expressions that always evaluate to the same value. For example, the IDE can now recognize possible string lengths or estimate string concatenation outcomes, prompting inspections when redundant or potentially problematic code is detected.

Kotlin

• Onboarding tips in the sample project - For those new to IntelliJ IDEA and Kotlin, there is an option to open a new project containing sample code, which now comes with onboarding tips. In the New Project wizard, check Generate code with onboarding tips to get a basic sandbox project with hints demonstrating some of the IDE's essential features.
• Compact Kotlin project structure for JPS - For the IntelliJ build system, you can now create a project that uses a concise project structure with less folder nesting. The path to the Main file appears as src/Main.kt instead of src/main/kotlin/Main.kt. This helps you save time navigating the project and reduces the overall complexity in projects where extensive nesting isn't needed.
• Auto-configuration for Kotlin in Java Gradle projects - If you add a Kotlin file to a Java module, IntelliJ IDEA can now automatically add all the necessary Kotlin dependencies by changing the build scripts. You can easily review these changes and undo them. Auto-configuration is currently available for Gradle projects that meet specific criteria.
• K2 compiler [Beta] - Projects that use the K2 compiler are now fully supported in the IDE, and the bundled Kotlin IDE plugin treats them the same as K1-based projects.
• Support for the latest Kotlin version included in IDE updates - As of this release, support for new Kotlin versions comes bundled in IntelliJ IDEA and Android Studio updates, meaning that you no longer need to update the Kotlin plugin from JetBrains Marketplace. With every major IDE release, you can expect built-in support for upcoming Beta and Stable versions of Kotlin.
• KMP wizard - Introduced a new way to create Kotlin Multiplatform projects - the Kotlin Multiplatform web wizard. The wizard ensures the same user experience on all platforms, and it also means you will get new updates faster as they come out independently of the major IDE releases. The new wizard currently covers the most popular Kotlin Multiplatform use cases.
• Kotlin modules - With this release, it is once again possible to add Kotlin modules to your project, meaning that you can create multi-module Kotlin projects with ease.

Scala

• Better Scala 3 support - IntelliJ IDEA now offers enhanced Scala 3 support with a particular focus on enums. The IDE now detects and warns about unextendable enums, provides improved propagation of annotations and modifiers to generated symbols, and offers precise type widening of apply methods, considering only direct supers. Errors due to duplicate synthetic elements are now highlighted correctly, and auto-completion for enums has been enhanced. Furthermore, Scala 3 code analysis has been improved, eliminating the invalid error highlighting that occasionally occurred in seemingly random cases. Code highlighting for inline parameter modifiers has also been refined, in addition to enhancing the Parameter Info popup.
• Improved syntax highlighting for Scala - IntelliJ IDEA has become much better at detecting unreachable code, and many red code false positives have been eliminated. The IDE now accurately identifies code used within the context of thrown exceptions and try, catch, and finally blocks, while also taking into account implicit imports. Additionally, the ability to suppress the Unused declaration has been introduced and Method can now be private inspections for non-standard Scala files, like worksheets.
• Enhanced inlay hint settings - Revamped the workflow for configuring inlay hints for Scala, making it easier to understand the types of inlay hints available and how to utilize them. These hints are now aligned and positioned on the right-hand side of the screen, ensuring they don't obstruct your code.
• The X-Ray feature - Inlay hints and other information that appears in the editor is meant to enhance code readability and make coding easier. However, too much detail can clutter the interface. With the new X-Ray feature for Scala, you can disable these hints and then double-press and hold Ctrl to toggle them back on when you need additional information. This allows you to keep the editor clean until you want to consult the hints.
• UI improvements for Scala - Scala settings are now easily discoverable through text search. In the Find Usages pane, the File Structure button has been added, allowing you to access more comprehensive information about how specific elements are used within your codebase. To improve the readability of your code, the Structure tool window now uses ?=> to distinguish implicit parameters from regular ones. New icons have also been introduced for runnable objects, test classes, exception classes, and enums in both the Structure and Project tool windows.
• Using directives - Improved support for the Scala CLI in several ways. First, you can now use auto-completion for using directives, and when you do, their elements are automatically formatted and highlighted correctly. Second, when you auto-import a symbol, it will be seamlessly integrated into the file under the using directives, resulting in cleaner and more organized code.
• sbt improvements - Previously, the Scala plugin included transitive dependencies among the direct ones, leading to instances where unnecessary project dependencies were considered. The plugin now calculates all transitive dependencies while importing or reloading. This revised approach gives you more control over the project structure. sbt modules now correctly depend on the standard Scala library, eliminating any instances where they might mistakenly rely on the Scala SDK.

Version control systems

• Support for GitLab snippets - Expanding on the GitLab integration introduced with the IntelliJ IDEA 2023.2 release, support has been added for GitLab snippets. You can now create public or private snippets directly within the IDE.
• All-in-one diff viewer - Introduced a revamped way to review changes. Now, instead of going through each file one by one, you can see all of the modified files from a changeset in a single scrollable frame. This new diff viewer is compatible with GitLab, GitHub, and JetBrains Space reviews.

Build tools

• Faster Gradle importing and indexing - Gradle projects now open faster because the IDE no longer automatically downloads the source JAR files for all dependencies. If you need to access specific source files, you can navigate to them using the Ctrl+B shortcut and opt to download them when prompted by the IDE.
• Fast Maven import for all projects - The new fast Maven project import mechanics have been enabled for all projects, including ones created using the older import implementation. This significantly improves the import time. The first time you open a project in this version, the IDE will perform a full resync and notify you about the migration.
• Grouping of Maven project modules based on their qualified names - Revamped the way the IDE handles the grouping of project modules. It now automatically groups modules based on their qualified names. If you need to, you can manually rename modules, and these names will persist during subsequent reloadings of Maven projects.
• Maven support updates - Maven 3.9.3 is now bundled with IntelliJ IDEA. The IDE no longer supports Maven 3.0.

Frameworks and technologies

• Enhanced Structure tool window in the HTTP Client - Improved the Structure tool window in the HTTP Client to streamline navigation within large .http files. This update introduces color-coded labels for request types and lists their contents more clearly.
• Support for in-place variables in the HTTP Client - The HTTP Client now supports declaring variables using @. You no longer need any extra environment files to reuse values across requests, and the IDE provides code completion for the values so you can easily add them.
• OAuth 2.0 Support - The HTTP Client now provides support for authentication with the OAuth 2.0 Password and Client Credentials grant types. With this update, you can reference authentication data in your requests using the new syntax {$auth.token("my-keycloak1")} and navigate to the JSON file containing the authentication details. This change streamlines the request execution process, eliminating the need to manually retrieve tokens.
• Enhanced JSON request body completion in the HTTP Client - This release makes it easier to work with JSON request bodies when generating HTTP requests. The IDE now inserts all required parameters on the first level of the request body. It also provides autocompletion for nested JSON objects and arrays.
• Visual editing for OpenAPI specifications - Implemented visual editing capabilities to help you quickly compose well-formatted OpenAPI specifications using live templates. These actions are available for both YAML and JSON files.
• Preview for OpenAPI specifications 3.1 with Swagger UI 5.0 - The integrated version of Swagger UI has been updated to 5.0. You can switch between Redoc and the updated Swagger UI preview in OpenAPI files via the floating toolbar action. As of v5.0, Swagger UI also supports OpenAPI 3.1 specifications.
• Automatic code completion for URL path references - Improved the code completion functionality for handling URLs. When you type / in places where a URL path is expected, the IDE now automatically populates the code completion popup with the URLs of server endpoints. When doing so, it considers both available APIs within your application and attached OpenAPI specifications to help you specify the URL path more quickly.
• Quarkus and Micronaut beans in the Beans tool window - In addition to Spring components, the Beans tool window now also includes Quarkus and Micronaut ones to provide a comprehensive and well-structured overview of your project's bean configuration.
• Support for the Micronaut expression language - IntelliJ IDEA now provides code highlighting, completion, and inspections for the Micronaut expression language. It also provides corresponding syntax highlighting in all relevant annotations.
• Support for Quarkus Qute type-safe templates - Added support for Quarkus Qute type-safe templates, meaning it now provides code completion for parameter declarations, available parameters, and parameter instance members.
• Run with Coverage and Profile with IntelliJ Profiler available for Quarkus projects - You can now use the Run with Coverage and Profile with IntelliJ Profiler run configurations for Quarkus projects. Both run configurations can be conveniently accessed directly from the Run widget.
• Spring 6.1 feature support - Support for Spring 6.1 features has been extended. For the new RestClient, the IDE now offers full support, including URL autocompletion, the Find Usages functionality, and the ability to view all client usages in the Endpoints tool window. In addition, SQL highlighting and parameter name code completion has been implemented for the new JdbcClient. IntelliJ IDEA now also recognizes the @Scheduled scheduler attribute, providing completion suggestions and validation for bean names used within this context.
• Spring GraphQL support - Introduced a new Spring GraphQL plugin that adds several valuable features for developing Spring applications built with GraphQL Java. When the plugin is installed, the IDE offers code navigation and completion suggestions for Spring GraphQL, as well as schema mapping. You can also navigate to GraphQL schema implementations and view them in the Endpoints tool window.
• Integration of the GraphQL plugin with the HTTP Client - Integrated the GraphQL plugin with the HTTP Client. You can now generate GraphQL requests, introduce variable injections into message bodies, and benefit from code completion capabilities while working with GraphQL injections, all in the HTTP Client.
• Option to add and edit Spring Boot starters via Spring Initializer - You can now add and modify Spring Boot starters within an existing module of your project, making it easier to manage Maven and Gradle dependencies and adjust your project's configuration.
• Option to create data sources from Spring Boot configurations - Added the ability to automatically detect and add data source configurations based on your Spring Boot application.yaml and application.properties files.
• Option to establish Kafka connections in Spring projects - IntelliJ IDEA is now capable of creating Kafka connections in Spring-based applications, leveraging the data from both the application.yaml and the application.properties configuration files.
• Bicep support - Introduced initial support for Bicep, an infrastructure-as-code language tailored for Azure. It translates into Azure Resource Manager (ARM) templates and is intended for close integration with Azure services. The IDE now offers code highlighting along with code completion that is facilitated through the language server protocol for Bicep.

Remote development and collaboration

• Improved support for Dev Containers - Support for Dev Containers has been significantly extended. You can now easily add extra development tools, runtimes, and libraries using Dev Container Features, simplifying the setup of essential components. Docker Compose support has also been introduced for Dev Containers, allowing you to launch both the main container and dependent containers from the IDE. In addition, automatic port forwarding has been implemented, meaning that any ports the application starts listening to in a Dev Container are seamlessly forwarded.

Kubernetes

• Working with databases in Kubernetes - Improved user experience when working with databases hosted in Kubernetes. For example, you can now configure port forwarding within Kubernetes while establishing a database connection.
• Support for $schema within comments in YAML files - The IDE can now identify references to specific YAML schemas included as comments. It also provides code completion and syntax validation within YAML files based on the specified schema, regardless of whether it's stored locally or accessed remotely.
• Option to add cluster contexts from a file - You can now easily add kubeconfig contexts from clusters located in directories outside of the required system. The project will include links to kubeconfig files, making these clusters available while you work on your project. The kubeconfig contents added in this way won't be copied to or modified in the system (~/.kube/config). This feature is especially useful when you frequently add and remove Kubernetes clusters from cloud or on-premises environments.
• Auto-installation of Kubernetes tooling - When you start using the Kubernetes plugin, which is now bundled with IntelliJ IDEA, you may need to install kubectl and/or Helm. If you don't have them on your computer already, the IDE will now offer to automatically install them for you.
• Improved debugging with Telepresence
  • Telepresence allows you to debug the microservices of a Kubernetes application locally, as if your workstation were a part of the cluster. By connecting to the cluster using Telepresence, you gain access to the cluster's namespace from your workstation and can interact with the DNS names of other microservices. With Telepresence interception, you can redirect traffic from other cluster services to selected ports on your workstation and debug microservices entirely locally using familiar IDE tools.
  • In this release, the Telepresence workflow has been made more accessible by moving it to the cluster's context menu. Interception management has also been streamlined for a smoother debugging experience.
• Support for import blocks in Terraform - Added support for top-level import blocks from version 1.5 of the Terraform configuration language. Import blocks allow you to bring the current infrastructure under Terraform's management. When import is used within a code block, it becomes part of the standard plan and apply stages and ceases to be a state operation. Terraform performs automatic code generation for imported resources, saving you time when developing infrastructure as code.

Performance

• Download of shared JDK indexes enabled by default - To boost the IDE's startup speed, the download of shared JDK indexes has been made the default. IntelliJ IDEA will now seamlessly connect to a dedicated resource in the background, fetching and applying shared indexes for your JDK automatically.

Database tools

• Data visualization - Integrated the Lets-Plot library for streamlined, no-code data visualization.
• Reworked import functionality - Reworked import functionality, marking the completion of the transition to the new Modify Object UI. It is now possible to import to multiple targets and make simultaneous edits, such as by changing the formats or encoding for several files or altering schemas for multiple targets.
• Introspection improvements - This release introduces a number of updates for introspection:
  • Introspection intervals for each data source.
  • Automatic introspection level for Oracle.
  • Support for new objects in SQL Server: partition functions, partition schemes, partitions and related table and index properties, ledger tables, and filegroups.
  • Support for materialized views in Redshift, which are now introspected and displayed in a dedicated node.
• Customizable number formats in the data editor - This release provides much greater flexibility regarding how numbers appear in the data editor. Most significantly, you can specify the decimal and grouping separators.
• DynamoDB support - Introduced DynamoDB support, including a data viewer, PartiQL support in the editor, and introspection for tables that have keys and indexes.

Web development

• Improvements for TypeScript - Added the option to configure the usage of the TypeScript import type statement or type specifier when importing a type. The behavior for the exports field of package.json has also been improved for TypeScript files.
• Improvements for Vue 3 - Added support for defineSlots, providing completion and navigation for the slot name, as well as rename refactoring. Completion support has also been introduced for properties with defineExpose. In this release, required imports for components will be added based on the name specified by the defineOptions function.
• Improved Angular support - Improved support for strict template type checking in Angular templates. the new control-flow syntax from v17 and signals, including live templates like signal, computed, and effect have also been supported. There are also new quick-fixes available with Alt+Enter. For example, you can create @Input and @Output properties from a component template.
• New functionality for testing JavaScript - This release brings new capabilities for testing your JavaScript code. Cypress and Playwright tests are now automatically detected and can be run from a Run icon in the editor. Initial support has also been introduced for the native Node.js test runner. Tests declared with the node:test API are now recognized, enabling running and debugging directly from your code without extra packages.

Space integration

• Start coding directly from a repository or code review - Navigate from a repository or code review in Space to the corresponding files in your IDE via the Start coding button.
• Start a branch from Space issues - With the Space issue flow, you can now start coding in the relevant repository directly from the issue. A branch is automatically created and then the IDE suggests creating a merge request when you push the changes.
• Search Maven packages - IntelliJ IDEA now recognizes Maven packages hosted in Space repos and suggests them in the code completion pop-up.

Other

• Plugin updates - Changes have been made to plugin distribution. The Android, Ant, and GlassFish plugins are now available through JetBrains Marketplace.