AI Assistant has received several valuable updates, including improved test generation and
cloud code completion, custom prompts for commit messages, the ability to create
files from code snippets, and updated in-editor code generation. Learn more in this
blog post.

Please note that in version 2024.1, AI Assistant has been unbundled and is now
available as a separate
plugin.
This change is driven by the need to offer greater flexibility in decision-making
regarding the use of AI-powered technologies, providing you with more control over
your preferences and requirements in your working environments. AI Assistant still
requires an active
JetBrains AI subscription.

We’ve enhanced code highlighting for Java and Kotlin within AI Assistant’s responses.
Code in the AI chat is now highlighted just as it would be in the editor, making
it easier to assess quickly. This enhancement is designed to make working with AI
Assistant’s suggestions more intuitive by offering an editor-like experience right
within the chat.

Basic IDE functionalities like code highlighting and completion now work for Java
and Kotlin during project indexing, which should enhance your startup experience.
Additionally, you can navigate through the code using Go to class and
Go to symbol while the project is still loading.

To reduce your cognitive load while configuring new projects, we have made slight
adjustments to the layout of the New Project wizard. The language list is
now positioned in the upper left-hand corner, enhancing the discoverability of
the most popular options.

In version 2024.1, we’ve revamped the Conflicts Detected dialog to improve
readability. Now the code in the dialog mirrors what’s in the editor, giving you
clearer insight into conflicts, and the IDE automatically saves window size
adjustments for future use. Plus, we’ve updated the buttons and their behavior
to streamline the refactoring workflow, and the dialog is now fully accessible
via the keyboard, meaning that you can use shortcuts and the arrow keys for
seamless interaction.

To make the renaming process easier and more intuitive, we’ve implemented a new
inlay hint that appears on top of the changed code element. To update all
references in the code base to the new version, you simply need to click on this
hint and confirm the change.

IntelliJ IDEA 2024.1 introduces the new Kotlin K2 mode, leveraging the embedded
K2 Kotlin compiler for enhanced Kotlin code analysis. This update not only
guarantees compatibility with upcoming Kotlin features, but also boosts the
stability of code analysis, resulting in the enhanced quality and reliability
of IDE features, as well as improved overall application performance.
Learn more.

Starting from version 2024.1, the IDE uniformly applies the official Kotlin style
guide as the default option for all projects, unless explicitly specified otherwise.
If your existing project happens to use an older code style without it being
explicitly configured, the IDE will automatically switch to the Kotlin coding
conventions code style and provide a notification to alert you of this change.
To prevent any undesired formatting alterations, we recommend familiarizing
yourself with this
code style migration guide.

In the new release, we’ve fixed many issues related to how specific syntax cases
in Scala 3 are handled. The improvements include the ability to recognize prohibited
mixes of modifiers, calculate indentation depth, cut and paste operations without
breaking indentation, and associate end markers with their syntax structures. We
also improved the Scala 3 support in the debugger, and autocompletion now accurately
handles some corner cases, such as when it is used together with the
and keywords or with signatures.

We’ve made a lot of minor improvements and fixes to how classes, traits, and method
declarations are highlighted in Scaladoc popups and in the quick documentation popup.
Nested generic parameters are now highlighted correctly, and field access modifiers
are displayed. Additionally, the code inside Scaladoc blocks with triple braces is now
highlighted in the same way that standard Scala code is.

Until now, if you switched to another editor while using compiler-based highlighting,
the code was automatically recompiled. In version 2024.1, we’ve changed that. Whether
the code is recompiled now depends on whether the editor is in focus. This helps
the compiler-based highlighting react to external changes to source and
files more quickly and avoid situations where valid code is red.

The IDE now adds a file to new SBT projects. We fixed
an issue where an exception was thrown when running Scala/JVM applications for
the first time with Use sbt for builds, and we ensured that all of a
module’s transitive dependencies are inserted as direct dependencies during import.

We’ve introduced new icons: one for the Scala language in the New Project
wizard and another for SBT in View | Tool windows. Additionally, you’ll
notice subtle enhancements in how inlay hints are presented, with rounded corners
and improved alignment. Furthermore, we’ve added Scala documentation to the
Settings | Editor | CodeStyle help page. In worksheets, compilation errors
are once again reported correctly in the build window when using Scala 2.13.12,
and imports are no longer incorrectly marked as unused before the first code
compilation. Moreover, you can now pin down the X-Ray feature, ensuring it remains
active even after releasing the Ctrl key.

IntelliJ IDEA 2024.1 introduces an enhanced code review experience for both GitHub
and GitLab users with the implementation of a new review mode. Integrated within
the editor, this feature facilitates direct interaction between authors and reviewers.
Upon checking the pull/merge request branch, review mode activates automatically
and pink markers appear in the gutter, indicating that code changes are available
for review. Clicking on these markers reveals a popup displaying the original code
so you can quickly identify what has been changed. Gutter icons help you swiftly
initiate new discussions, as well as view and hide existing ones. They also provide
easy access to comments, making it easy to review, reply, and react to them. Learn
more about this change in our
blog post.

IntelliJ IDEA 2024.1 streamlines the code review workflow by offering a focused
view of branch-related changes. For GitHub, GitLab, and Space, it is now possible
to see changes in a certain branch in a separate Log tab within the Git
tool window. To do so, click on the branch name in the Pull Requests tool
window and pick Show in Git Log from the menu.

IntelliJ IDEA 2024.1 brings support for posting reactions to review comments for
GitHub pull requests and GitLab merge requests, with a set of emojis already
available to choose from.

We’ve introduced a new column in the Log tab of the Git tool window,
allowing you to easily review the results of GitHub commit checks performed by your
CI system.

After successfully pushing your changes to the version control system, the IDE
will now alert you with a single notification informing you about the successful
push and suggesting an action to create a pull/merge request.

We’ve introduced visual indicators to inform you about pending updates within
your code review workflow. When there are changes that require your attention,
a dot will appear on the tool window icon. Unseen pull requests will also be
marked with a blue dot, ensuring you don’t miss updates in your code review process.

To help you avoid version control rejections due to oversized files, the IDE now
includes a pre-commit check that prevents you from committing such files and
notifies you of the restriction.

The Merge into dialog now has an Allow unrelated histories option
in the drop-down menu. When selected, it allows two branches to be merged even if
they have no common history.

In the Git tool window, the Show all branches button has been replaced
with a branch filter, allowing you to review changes made to a file within a
designated branch. We’ve also adjusted the orientation of the toolbar, positioning
it horizontally for improved usability.

For users who rely on stashes to store temporary uncommitted changes, we’ve
introduced a dedicated tab within the Commit tool window for convenient
access. If you use both stashes and shelves, you have the option to enable a
combined Stashes and Shelves tab via a corresponding checkbox in
Settings/Preferences | Version Control | Git.

In the diff viewer, you can now specify folders and files to be ignored during
the comparison process in order to focus solely on relevant changes. Just
right-click on any file or folder you don’t want to appear in the comparison
results and select Exclude from results from the context menu.

In the Branches popup, you can now filter search results by actions and
repositories for quicker and more precise navigation within your version control
system.

IntelliJ IDEA now constructs the project model by parsing the
files. This makes it possible to get a working project structure in seconds while
the complete project model with all the dependencies is built in the background,
allowing you to dive into the project without waiting for the full sync to finish.

With the release of IntelliJ IDEA 2024.1, we’re adding the long-awaited support
for the Maven Shade Plugin’s renaming functionality. Now, IntelliJ IDEA is aware
of the renaming workflow, providing accurate code highlighting and navigation
when working with your shaded JAR and its dependencies.

The quick documentation popup now provides an easy way to download source code.
Now, when you’re viewing documentation for a library or dependency and need to
access its source code, you can simply press F1. The updated popup
will provide a direct link you can use to download the required source files,
streamlining your workflow.

The list of Maven repositories, along with their indexing statuses, is now
displayed in the Maven tool window, instead of its previous location
in the Maven settings.

Starting from this version, IntelliJ IDEA no longer supports projects using Gradle
versions older than 4.5, and the IDE will not perform Gradle sync for projects with
unsupported Gradle versions.

Library calls are now folded by default in the Debug tool window’s call stack,
helping you maintain your focus when browsing your code. However, if you need to
verify a library call sequence, you can expand the group and explore the frames
accordingly. To reveal the list, use the Filter icon in the toolbar or call
the context menu and disable the Hide Frames from Libraries option.

Version 2024.1 brings IntelliJ IDEA one step closer to achieving comprehensive
test coverage. This update focuses on identifying which conditional statements
in the code are not fully covered by tests. Now IntelliJ IDEA both shows which
line has an uncovered condition and specifies any conditional branches or variable
values that are not covered. This feature is enabled by default, and you can control
it in Settings/Preferences | Build, Execution, Deployment | Coverage.

Code coverage settings have been moved from the Run Configuration popup
to Settings/Preferences | Build, Execution, Deployment | Coverage. This
shift eliminates the need to individually update the configuration for each test
run to select a coverage runner or enable advanced features, like tracking which
tests cover a specific line of code.

We’ve made accessing Spring model diagrams easier. You can call them using bean
line markers or by using an intention action (Alt+Enter)
on Spring classes. We’ve introduced new icons for Spring diagrams, enhancing the
visualization of Spring stereotypes like components, controllers, repositories,
and configuration beans. Additionally, you can now conveniently toggle the
visibility of beans from libraries, which are hidden by default.

The HTTP Client in version 2024.1 offers more authentication options, including
the PKCE Authorization Code and Device Grant flows. It also supports extra
parameters for token and authentication requests, in addition to automatically
handling generation and
passing for token retrieval during PKCE requests. The HTTP
Client’s upgrade to Netty as its low-level networking library enables SSL, proxies,
and HTTP/2 support, facilitating the implementation of HTTP/2. Additionally, the
HTTP Client’s toolbar has been revamped to align with the style of the new UI,
providing a more polished and cohesive appearance.

We’ve introduced a new settings editor for Quarkus run configurations. Now the
Run/Debug Configuration dialog offers an improved UI for both Maven and
Gradle projects, with easy access to popular settings like Run profile and
Environment variables. For your convenience, the Quarkus Dev UI is easily
accessible via a new icon added to the Run tool window’s toolbar.

IntelliJ IDEA Ultimate 2024.1 brings improved Terraform support that simplifies
the process of creating, managing, and scaling your infrastructure. The IDE now
streamlines initialization via an explicit suggestion to run ,
and offers extended code completion capabilities for more than 3,900 third-party
Terraform providers. Additionally, the IDE introduces support for Terraform’s
template language (tftpl), enabling dynamic templating with the option to seamlessly
integrate it with your preferred programming language. You can find more details in our
blog post.

This release introduces the long-awaited local filtering feature in the data
editor. You can now swiftly filter rows by column values without sending queries
to the database. This local approach only impacts the current page, though you
can adjust the page size or fetch all the data if you need to extend the scope.
To disable all local filters, deselect the designated Enable Local Filter icon.

IntelliJ IDEA Ultimate 2024.1 streamlines query execution by eliminating the need
to manually select sessions. Instead, to attach a file, you simply need to choose
the data source, rather than the session. Additionally, launching functions no
longer requires selecting a session; you can now opt to run functions directly
from the console or file. These changes aim to minimize the learning curve with
the tool, reducing unnecessary steps and enhancing overall usability.

We have significantly enhanced the quick documentation popup. It now supports syntax
highlighting for code blocks. In TypeScript, it now shows interface members, enum
constants, and type alias bodies. You can use the Show more link to expand
the full list of type members and navigate to the referenced types. Additionally,
it’s now possible to navigate between multiple declarations of interfaces, type
aliases, enums, functions, and other entities using the paging control at the top
of the dialog.

IntelliJ IDEA Ultimate 2024.1 introduces several new quick-fixes for React that
let you create props and states on the fly. You can apply these quick-fixes using
the shortcut Alt+Enter.