2019.2 Jul 24


Java 13

IntelliJ IDEA is getting ready to welcome new Java 13 Preview features. The IDE provides support for updated Switch Expressions and their new syntax: now if you need to return a value from a multi-line block in Java 13, you can use the yield keyword instead of break. We’ve also added support for text blocks, which allows you to embed longer multi-line blocks of text into your source code, for example, HTML or SQL. With this feature, you paste across the two formats, either escaping values when pasting into a String or leaving out the escapes when pasting into a text block.

Refactoring methods with multiple exit points

We’ve added a new intention that you can run to transform a method with multiple returns into a single exit point and prepare it for the Inline Method refactoring. A method may include multiple exit points by defining multiple return statements. When you inline such a method in IntelliJ IDEA, it can be modified to define just one exit point in the form of a single return statement to exit the method. Such methods are less confusing as you have one path through them and you don’t need to search for the exit.

‘Constant conditions & exceptions’ pinpoints the source of the problem

We’ve topped off the good old ‘Constant conditions & exceptions’ inspection with a new action called ‘Find Cause’. In addition to notifying you about possible or actual issues, the inspection navigates you to the questionable piece of code. No more reading through the file and searching for the necessary line.

Modified inspection weeds out duplicates from your codeUltimate

We’ve merged the ‘Duplicated code fragment’ inspection for Java with the ‘Locate duplicates’ tool for other languages, to give you a powerful new inspection called ‘Duplicated code fragment’ which combines the best of both worlds. It’s configurable, works on the fly, and supports lots of languages other than Java.

Updated completion popup suggests correcting mistyped patterns

In IntelliJ IDEA 2019.2, we’ve changed the look of the code completion popup and made it even more helpful. From now on, completion recognizes mistyped patterns and suggests possible fixes, so if you type “retru” by accident, the IDE will suggest replacing it with “return”.

Structural Search shows occurrences instantly

Structural Search is a powerful feature that allows you to search for a specific code pattern in your project. IntelliJ IDEA highlights strings that match your search in the editor as you type. What’s more, the IDE displays the filter values right in the editing area of the Structural Search dialog. There is no more need to continuously re-run the search while you are experimenting with the pattern.

Profiling Tools

IntelliJ IDEA now offers profiling toolsUltimate

Now you can analyze the performance of your application right inside your IDE as IntelliJ IDEA is integrated with Java Flight Recorder on Windows, macOS, and Linux.

macOS and Linux users can also enjoy the Async Profiler. This tool can easily become your best friend as it tells you everything about how memory and CPU are allocated in your application.


Services tool window: a single control panel for all connections, configurations, and more

Now you have everything you need to control all under one view. A brand new Services tool window condenses and encapsulates the most useful tools: RunDashboard, Database Console, Docker, and Application Servers views. It also provides a single display and control point for connections, run and debug configurations, application servers, database consoles, and more. For databases, the tool window features the query live timer which shows you the duration of each connection running a query.

A running Docker container lets you view its file system

In IntelliJ IDEA 2019.2, you can view the file system of a running Docker container in the Files tab of the Docker node in the Services tool window.


This release improves the performance and UI responsiveness for the file system refresh, and reduces most delays caused by processing filesystem changes. We’ve gone to great lengths to optimize the startup performance, so you should feel a boost as soon as your start the IDE.


Each directory can have its own code style

You can now have a separate code style configuration for each folder. Fancy trying it? Place an EditorConfig file in the root directory of a module or a package, and you are good to go.

The IDE can now manage all code style settings via the EditorConfig file. All adjustments are now visible in the preview, so your days of blind fiddling with the settings are over.

Learn more.

Syntax highlighting is available for over 20 languages

IntelliJ IDEA is now integrated with the TextMate editor to provide out-of-the-box syntax highlighting for over 20 different programming languages. If you need to add highlighting for any additional languages, all you need is to do is to download the TextMate bundle for the language and import it into the IDE.

The ‘Move Caret to Next Word’ action provides options

Now you can choose where to place the caret: at the end of the current word or at the beginning of the next word. Pick the behavior that works best for you in the Caret Movement option in Settings/Preferences | Editor | General.

Tab now takes you outside the closing bracket or quote

Another feature to help you type faster is now enabled out of the box: the Tab key navigates you outside of the closing brackets or quotes. This feature works only when you’re typing.

To disable this option, go to Settings/Preferences | Editor | General | Smart Keys and deselect the ‘Jump outside closing bracket/quote with Tab when typing’ checkbox.

Selected code gets wrapped in quotes or braces automatically

Although it’s not technically brand new, this super handy feature is now enabled by default: when you type a brace or a quote, IntelliJ IDEA automatically wraps the selected code in braces or quotes.

If you don’t like this feature as much as we do, go to Settings/Preferences | Editor | General | Smart Keys and deselect the ‘Surround selection on typing quote or brace’ checkbox.

macOS now has a new default keymap

We’ve changed the default keymap for macOS from Mac OS X to macOS 10.5+. We’ve also renamed the keymaps: Mac OS X 10.5 is now called Default for macOS, and the outdated Mac OS X is now IntelliJ IDEA Classic.

IntelliJ IDEA works with large files smoothly

You can now easily open files larger than 25MB in IntelliJ IDEA and search through them without tedious waiting. This is a very nice little improvement for those of you who work with the log files.


Inspection popup shows the most relevant fix

This release delivers fixes suggested by code inspections even faster. Now the inspection popup not only describes the problem, but also shows you the most relevant solution straight away. Press Alt+Shift+Enter if the fix works for you, or use the Alt+Enter shortcut to pick another option from the list.

New Class dialog gets a new look

The New Class dialog has a new look. What’s more, now it lets you preview the types of classes you can create.

Windows User interface has a fresh classy appearance

On Windows 10, the IDE now has a new modern borderless look.

Project View now shows file size and modification time

A new option helps you keep an eye on what’s going on in your project and shows the size and modification timestamps for all items in the Project View tree. To enable the feature, select View | Appearance | Descriptions in Tree Views.

Editor and debugger tabs get a unified look

The design of the editor and debugger tabs has changed to look the same in the Light and Darcula themes. In the Light theme, we’ve aligned the tab’s height with the height of the tool window header. We’ve also removed the white line under the tabs to minimize visual clutter.

Find Usages toolbar becomes more elegant

Continuing the trend of removing unpopular icons from toolbars and making them less visually loaded, we’ve trimmed down the toolbar of the Find Usages tool window. Some icons are now grouped and some are gone completely.


Gradle features a new Dependencies diagramUltimate

In this release, we’ve added the long-awaited Gradle Dependencies diagram. Just click the Show Dependencies icon on the Gradle tool window toolbar or press Alt+Shift+Ctrl+U/Alt+Shift+Cmd+U. Select the nodes from this diagram to look at their neighbors, and click the nodes to see how they are connected to the root.

More coding assistance features added for build.gradle files

Starting with version 2019.2, you can edit build.gradle files more easily. IntelliJ IDEA now supports the task declaration syntax and various dependency notations, and offers code completion inside dependency blocks and dependency configuration closures.

Gradle task output is improved

The status tree and output console of Gradle operations are now shown side by side to help you monitor the sync/build process. This offers you more detailed and familiar Gradle output information.

Working with Gradle settings gets easier

We’ve simplified the Gradle settings dialog by deprecating several options. What’s more, IntelliJ IDEA automatically configures the settings for you when you open, import, or create Gradle projects.


Maven sync output is shown in the Build tool window

IntelliJ IDEA now reports the Maven import process in the Build tool window, together with the Maven build output. This makes the progress and error reporting more visible, simplifies navigation, and makes the Gradle/Maven experience more consistent.

Maven dependency completion works out of the box

Code completion for dependencies in the pom.xml now works out of the box. Previously, it only worked if you triggered the indexing of your Maven repository.

Version Control

The native ignore file handling is now fully supported

In this release, we added the native ignore file handling for Git. From now on, the native ignore file handling is available for all supported version control systems out of the box.

You will no longer need to manually add files to the .gitignore list in the settings. Everything is much simpler now: add a file to the list of ignored files from either the Project Tree or the Local Changes tab of the VCS tool window. The .ignore plugin that used to offer Git ignore and HG ignore support now only provides advanced functionality of VCS ignores, as the main functionality is part of the platform.

Commit files from the Local Changes tab

IntelliJ IDEA 2019.2 brings a big change for projects that use Git or Mercurial. There’s no need to open a separate dialog to commit files; now you can commit files from the Local Changes tab of the Version Control tool window. There, you can review the modified files and make changes if necessary because the commit dialog doesn’t block the rest of the IDE.

To give it a go, select the ‘Commit from the Local Changes without showing a dialog’ checkbox in Settings/Preferences | Version Control | Commit Dialog.

Smart VCS integration reminds you to commit files

IntelliJ IDEA 2019.2 reminds you to modify the files you have usually committed before together with the files you modified recently.

The IDE suggests adding files copied externally to VCS

IntelliJ IDEA prompts you to add any files copied into the project from outside the IDE, or files created in the console or during code execution to version control. You can also configure the IDE to add such files automatically.

VCS Log tab allows you to select the information to show

Now you can choose which columns you want to see in the VCS Log tab. Click the eye icon, select ‘Show Columns’, and then select the columns you want to display: author, date, or commit hash.

Git Merge and Cherry-Pick can be aborted from the UI

Now you don’t need to switch to the terminal to abort Git Merge or Cherry-Pick anymore. The Abort Merge/Abort Cherry-pick option shows up in the Branches popup while the process is running.

Show History for a folder displays results on the Git Log tab

Track changes in your project with ease. Now, when you use the Git | Show History action on the selected directory in the Project View, the IDE displays the results in the Log tab filtered by the respective path.

You can also see the changes that were made in multiple folders all at once. Right-click the folders where you want to check the updates and select Git | Show History.

Update Info after Update Project action is shown as Log tab

Previously, when you used the Update Project and Pull actions, the IDE would show a tree of updated files in the Update Info tab of the Version Control tool window. In v2019.2, the Update Info is displayed as a list of commits received during the update. The Update Info tab now looks like the Log tab.

Comparing branches becomes more convenient

The ‘Compare with Current’ action in the Branches popup is divided into 2 separate actions: ‘Compare with Current’ and ‘Show Diff with Working Tree’. The updated ‘Compare with Current’ action now shows the difference in commits, while the new ‘Show Diff with Working Tree’ action shows the file diff.

Diff now shows the method with modified code

While in the “Collapse Unchanged Fragments” mode, the Diff now shows the method in which the current chunk of code is modified. It makes it easier for you to not only see the change, but to understand the context as well.


The bundled Kotlin plugin in IntelliJ IDEA is now updated to v1.3.41.

JPA for Kotlin gets more coding assistance featuresUltimate

IntelliJ IDEA 2019.2 comes with a wider range of JPA coding assistance features for Kotlin. Now you can generate Kotlin entity classes on selected tables with the Generate Kotlin Entities script. The script is easily customizable; go to the Scripts Directory and experiment with the script by modifying it to solve a specific task. What’s more, the IDE can now navigate you to the corresponding column or table with the ‘Go to Declaration’ action (Cmd+B/Ctrl+B).

‘Async stack trace’ shows the variable state at the last point of suspension

When you stop at a breakpoint inside a suspend function or a lambda, ‘Async stack trace’ now shows you the state of the variables at the last point of suspension. You can browse the whole stack trace of suspend functions starting from the last suspension point in the current coroutine and check the stored values of the variables. This can help you understand how you got to the current point of execution.

Interactive mode for scratch files shows changes on the fly

As you know, in Kotlin you can perform small experiments with your codebase using scratch files. Now you can use the interactive mode which shows you the results on the fly after a certain timeout, without the need to explicitly rerun the script.

TODO list displays multiline comments for Kotlin

How often do you check the TODO list in your project? IntelliJ IDEA now correctly highlights multiline TODO comments in Kotlin and displays them as a list in the TODO tool window.

The IDE warns you on incorrect external annotations

If you use external nullability annotations for Java, the IDE can now warn you about incorrect usages of annotated Java methods from Kotlin. Note that this is purely IDE functionality; the corresponding code is compiled without warnings by the Kotlin compiler, while the IDE shows an additional warning.


We’ve extended the Groovy 3.0 syntax and our support for nested code blocks. Moreover, the IDE now makes the braces and arrows in a closure expression bold by default so that you can easily understand the structure of the code and distinguish code blocks from closures.

You can also enjoy quick-fixes that add explicit types for all the parameters in a method declaration for Groovy methods where the types of the parameters aren’t explicitly defined.


New way to highlight type mismatches

Instead of underlining type mismatch errors with a red squiggle, which might span across multiple lines, IntelliJ IDEA now shows a type ascription hint and highlights the part that doesn’t match the expected type.

Learn more.

Type mismatch tooltips show diff

Type mismatch tooltips are now fine-grained, vertically-aligned, and offer pairwise comparison. The algorithm takes syntactic sugar, subtyping, variance, and other tricky stuff into account.

Type hints are interactive

Type annotation hints now support dynamic folding, tooltips, navigation, and brace matching. The type hints are now shown only when truly needed.

Expressions are wrapped / unwrapped as you type

Previously, you had to use intentions to wrap (or unwrap) expressions inside curly braces. Now IntelliJ IDEA can do that automatically, as you type.

Redundant code is now unobtrusive

IntelliJ IDEA has always used grey to mark unused imports or unreachable code as “redundant” (as defined by the color scheme). Some other redundant code, however, was highlighted as “generic warning or error”, which polluted code and concealed actual errors. Now we use grey to color all redundant code uniformly, so the highlighting is less obtrusive.

Improved code completion

You can now complete the whole case clause (whereas before, it was only possible to complete patterns in case clauses). Completion works not only for match statements, but for higher-order functions as well.

Enhanced language injectionsUltimate

Now you can inject languages into multiline string literals with margins.

Build Server Protocol is fully supported

IntelliJ IDEA now supports the Build Server Protocol (BSP), which standardizes how build tools (servers) and IDEs (clients) communicate with each other. For a while, BSP support was an experimental feature, but now it is a first-class citizen in the IDE.

JavaScript & TypeScript

New intention replaces an extra variable with another destructuringUltimate

With the new ‘Propagate to destructuring’ intention (Alt+Enter), you can replace an extra variable with another destructuring whenever possible. To remove a destructuring completely, use the intention action called ‘Replace destructuring with property or index access’. The IDE now warns you if a boolean expression in a condition has some unnecessary parts and suggests simplifying it.

Rename refactoring for JavaScript is now enhancedUltimate

When you rename a symbol in a JavaScript or TypeScript file, the IDE now groups together dynamic usages and, by default, excludes them from the refactoring. This makes the refactoring more accurate and gives you more control over what exactly should be renamed in the Refactoring Preview tool window.

Improved support for Vue.js allows for better completionUltimate

Using Vuetify or BootstrapVue in your Vue.js application? We’ve adopted a new approach to working with these libraries in the IDE. From now on, code completion for components and their props from these and some other Vue component libraries is more precise.

Node.JS is now bundled with IntelliJ IDEA UltimateUltimate

The Node.JS plugin now comes pre-installed with IntelliJ IDEA Ultimate.

Database Tools

Full-text Search offers comprehensive resultsUltimate

Now you can search for the data you need even if you don’t know its exact location. Right-click the data source or a group of data sources that you want to search through and select Full-text Search, or press Ctrl+Alt+Shift+F / Cmd+Alt+Shift+F.

The results are filtered to show you only those strings in which the data is found. If you cannot locate the data because there are too many columns, use the text search in the data editor (Ctrl/Cmd+F).

Filtering by data source available in search and navigationUltimate

Locating an object in the GoTo popup is not always easy, especially when there are too many similar items. In IntelliJ IDEA 2019.2, you can choose where to search: in a particular data source or in a group of sources. The same works for Find In Path. This is extremely useful if you are looking for source code inside of DDLs of other objects.

JVM Debugger

Step Into action offers you a choice of methods to step into

When you’re doing ‘step into’ on a line with several methods calls, you can choose the method, lambda, or method reference that you want to step into.

Shell Script

IntelliJ IDEA introduces shell script support

This release offers rich editing support for shell scripts, including word and path completion, Quick documentation, and even textual rename. You can also create run configurations for executing shell scripts – and that's only half the story. We’ve integrated several external tools into IntelliJ IDEA for even more advanced shell script support. From now on, you can use Shellcheck to detect and fix errors in your script, Shfmt to properly format your shell script, and Explainshell to get a full description of the necessary command by pressing Alt+Enter.

HTTP Client

HTTP client supports cURL requestsUltimate

Now you can paste a cURL request string into the HTTP client and have the IDE automatically convert it to a full request.

HTTP client keeps cookiesUltimate

Suppose you’ve made one request to authenticate on the service, and in subsequent requests you would like to call some endpoints that require additional permissions. Previously, you would lose the cookies from the first response. But not anymore: the IDE now keeps all the cookies for you and transfers them in the next requests.


The Terminal soft-wraps lines better

Previously, the Terminal could occasionally break links when wrapping lines, and some lines were wrapped improperly. Now, when you run a command that outputs a long line, the Terminal soft-wraps it gently, keeping all the links in the working state. If you click a wrapped link, it is immediately sent to your browser.

Exit codes for file merge from the command line

IntelliJ IDEA now returns proper exit codes when used as a command line tool for merging files. Now you can use IntelliJ IDEA as a merge tool in any custom workflow. We also support the --wait command line option for editing files from the terminal in a blocking manner.


Plugins page becomes more ergonomic

The IDE now displays plugin details on the Plugins page in the Settings/Preferences dialog right away, so you don’t have to click each plugin one by one. We’ve got rid of the Updates tab, and the ‘Update’ button is placed near the plugin name on the Installed tab. We’ve added new options under the gear icon, allowing you to disable or enable the downloaded plugins all at once. Save yourself a bunch of clicks and spend them on more important things.


Kubernetes plugin gets Kustomize supportUltimate

The new version of IntelliJ IDEA 2019.2 with the Kubernetes plugin provides editing support for Kustomize with completion for keys and paths, as well as many inspections for Kustomize resource files.

The Rename refactoring now works for renaming the files and directories of the Kustomize resource files. You can jump from a path declared in the Kustomize resource files to the associated packages or files in the Project tool window, with the Ctrl+B/Cmd+B shortcut.

External resources can be added using URLsUltimate

You can now load a custom resource definition (CRD) specification from external sources using URLs. To add the specifications, go to Settings/Preferences | Languages & Frameworks | Kubernetes and add URLs to the CRD specification. (Previously, it was possible to add a CRD from local files.)

your edition


For web and enterprise development


For JVM and Android development
License Commercial Open-source, Apache 2.0?
Java, Kotlin, Groovy, Scala
Android ?
Maven, Gradle, SBT
Git, SVN, Mercurial
JavaScript, TypeScript ?
Java EE, Spring, Play, Grails, Other Frameworks ?
Database Tools, SQL
Detecting Duplicates ?