What’s new in IntelliJ IDEA 2019.1

Java 12 Switch Expressions (Preview) support

IntelliJ IDEA 2019.1 comes with support for the Java 12 Preview feature – Switch Expressions according to JEP 325.

We have a number of new inspections and quick-fixes to help get you started. The IDE can detect any ‘switch’ statements that can be replaced with an enhanced ‘switch’ statement or expression, and it will provide a quick-fix for the conversion. The IDE will also detect duplicate branches in ‘switch’ and offer a quick fix to merge them. This is all just the tip of the iceberg.

Learn more

Extract variable refactoring enhancements

The “extract variable” refactoring has been significantly improved and it now preserves semantics even better than before. The IDE can extract a variable even from the field initializer, and the extract variable refactoring can convert a ternary to ‘if’ automatically when the condition is important. The condition is considered as important if it has a null check or the ‘instanceof’ check.

Precise warning highlighting in ternary expressions

IntelliJ IDEA 2019.1 ensures more precise warning highlighting for ternary expressions. It will only highlight a condition in which a nullability violation is detected (whereas previously it highlighted the whole ternary expression, even when the nullability was only violated in a single branch).

Thanks to this new feature, highlighting is more precise in switch expressions too.

Improved analysis of mathematical operations

The data flow analysis can track the result of mathematical operations and uses this information to warn you about conditions that are always true or false. We have improved the analysis of many math operations including multiplication, remainder, and bitwise operations.

Inference of constructor’s purity from sources

IntelliJ IDEA 2019.1 improves its support for the @Contract annotations. It can now automatically infer the purity of constructors from sources.

Navigation from Java stack trace to the relevant position within a line

When you click on the Java stack trace, the IDE will try to determine the exact location within the row to take the cursor to. Previously it would only take you to the first column of the corresponding row.

Duplicated switch branches detection

The IDE can now detect duplicated switch branches and provides a quick-fix to merge such branches.

Delegation of build and run actions to Gradle set per Gradle project

It’s now possible to delegate build and run actions to Gradle for each project individually. Configure this option for each Gradle project if your IntelliJ IDEA project consists of several Gradle projects. You can even set different values for the test runner and the application runner for the same project.

In IntelliJ IDEA 2019.1, the build and run actions are delegated to Gradle by default for new Gradle projects.

Proper selection of a Gradle test task to run from the editor

With IntelliJ IDEA 2019.1 we have improved the support for projects with the several Gradle source sets where the test execution is delegated to Gradle. Now the IDE correctly resolves which task should be executed when a specific test has been run. For choices with multiple options, the IDE provides a list of all the tasks that can be run for this selected test.

HotSwap works when build actions are delegated to Gradle or Maven

Now, when you are debugging with the build actions delegated to Gradle, the HotSwap is triggered, and building a project reloads classes.

Also, HotSwap works when build actions are delegated to Maven.

Maven build output reported to Build tool window

For convenience, all the Maven build output will now be shown in the single place – the Build tool window. There is no need to check in the Run or Messages windows anymore. You can also toggle the view and present the build output as a log.

Improved Maven Diagrams

Maven diagrams have been enhanced and extended with new options. You can easily find the conflicts and duplicated dependencies by using ‘Show Conflicts/Duplicates’. To view all paths to the node, click ‘Show Paths: Root -> Selection‘.

If you need to view only the dependencies of a node, select ‘Show Neighbors of Selected Nodes‘. You can also switch the diagram to the Borderless View.

Fixup and Squash actions were added to VCS log

Invoke Fixup and Squash actions from the context menu of the VCS Log tab, and these actions will create commits with the correct fixup! and squash! commit messages.

Ability to cherry-pick only some of the files right from the VCS log

With IntelliJ IDEA 2019.1 you can now cherry-pick select files from the commit while you are in the VCS log. Simply invoke the context menu and choose the “Apply Selected Changes” option.

Indication of incoming and outgoing commits

There is now the option to see the availability of incoming and outgoing commits for the individual branches in the Branches popup. You need to switch on the ‘Mark Branches that have incoming/outgoing commits in the Branches popup’ option in the Preferences/Settings | Version Control | Git.

Deleted shelved files can be restored

You can now view all the recently deleted files and restore any useful shelved files. Simply use the new “Recently Deleted” node in the Shelf tab of the VCS tool window.

New “Uncheck all” checkbox for partial Git commits

To make it more convenient, we’ve added a new “Uncheck all” checkbox to the Diff pane of the Commit Changes dialog, so now you can easily uncheck all the code chunks in one go.

Mode to view author initials for VCS annotations

You can now view the initials of the author instead of their full name in the VCS annotations. Right-click on the annotation tab and select View | Names | Initials from the context menu.

Adding file content to the Blank Diff Window by drag-n-drop

It is possible now to copy & paste text to a Blank Diff window by dragging a file to it.

Ability to switch sides of compared files in the diff viewer

You can now swap sides in the diff viewer when you open it with Compare two files, Compare with clipboard, or Blank Diff. To toggle which file is shown on the right and which on the left, simply select Swap Sides.

Swap Sides is also available for comparing directories.

Preview the difference by char unit

Now you can view the difference by char unit and not only by word unit, as it was before in the diff viewer. Could be pretty useful if your source code has any lines of characters from different alphabets, for example, Japanese.

Meet the brand new “Recent Locations” navigation popup, which displays all the recently visited and changed locations in the code. All the locations that you’ve visited are chronologically ordered in this popup with the latest location that was visited at the top, and the oldest visited locations at the bottom. To call up the new “Recent Locations” popup, press Cmd-Shift-E / Ctrl-Shift-E.

Support ‘synchronized’, ‘assert’ and ‘switch’ in the debugger evaluator

The debugger evaluator now supports synchronized statements, assert expressions, and switch statements.

Step out of code block in JVM debugger

It’s now possible to Step Out of the current block while you are debugging the Java project. This new action is available from the main menu | Run.

New “Run to mouse pointer” mouse gesture

Now, if you prefer to use the mouse in debug mode, you can hover over a line and the IDE will highlight this line, if you then click on a line number the IDE will perform the run to cursor action.

Highlighting of for-comprehensions

IntelliJ IDEA 2019.1 comes with enhanced for-comprehensions support including error highlighting, implicit hints, and GoTo / Quick Definition / Quick Documentation actions.

Find Usages for implicits

Find Usages can now be invoked on implicit definitions, apply / unapply methods, for-comprehension methods, and Single Abstract Method (SAM) types.

Decompile to Java

Now, even if the Scala .class files have no sources, you can decompile them to Java.

Customizable Scalafmt version

With IntelliJ IDEA v2018.2 we added support for the scalafmt formatter, and with this release, we have enhanced this ability. IntelliJ IDEA not only lets you use a custom Scalafmt version, but the IDE can also now download the required version for you.

Separate HOCON plugin

We've extracted the HOCON support into a separate repository and plugin, which you can install and uninstall on demand.

Error highlighting improvements

In this release, we have significantly improved the error highlighting in the number of areas including:

• Partial unification and type variable unification in general.
• Constructor highlighting, calls to private constructors.
• Better-monadic-for compiler plugin: `implicit0` feature.
• Kind-projector: value level polymorphic lambdas.
• Simulacrum: higher-arity type constructors.

Support for Java-style Lambda syntax of Groovy 3.0

IntelliJ IDEA 2019.1 supports the experimental Groovy 3.0 feature – Java-style Lambda syntax. The IDE provides editing support for it including code completion, highlighting, and type inference. The Groovy intentions and inspections will also work properly inside the lambda body. Formatting is also available for Java-style lambdas and you can debug Java-style lambdas too.

Live Template to generate ‘main’ without parameters

Starting with Kotlin 1.3, you can use the main function without parameters. Accordingly, with this release of IntelliJ IDEA, you can create the main method without parameters by using the ‘main’ live template.

Please note that now the default ‘main’ abbreviation creates the new version of the main method. If you need to pass some arguments, use the ‘maina’ abbreviation.

String conversion improvements

The ‘Convert concatenation to template’ intention can now remove the unnecessary .toString() calls on each parameter.

New intention for converting SAM as lambda to an anonymous object

If you need to convert a construct using lambdas with SAM to an anonymous object, use this handy new intention action.

Intention action to improve coroutine code

When you work with coroutines, IntelliJ IDEA suggests adding an “Async” suffix to a function returning ‘Deferred’.

New intentions for JavaScript destructuring

IntelliJ IDEA 2019.1 comes with a set of new refactorings and intentions to help you start using destructuring in your JavaScript or TypeScript code.

Intention to convert function with Promise to async/await

Change a function that returns a promise with .then() and .catch() calls to an async function that uses the async/await syntax. To use this quick-fix, press Alt-Enter on the name of the function and select Convert to async function. This is available for TypeScript, JavaScript, and Flow.

Updated documentation for CSS and HTML

The quick documentation for CSS properties and HTML tags and attribute (F1 / Ctrl-Q) now shows a short description from MDN, including its compatibility with the most popular browsers.

Improved JavaScript debugger console

The interactive debugger console in the JavaScript and Node.js debug tool windows now shows objects using a tree view, and it supports styling of log messages with CSS and grouping them using console.group() and console.groupEnd(). Also, it allows you to filter out any type of log messages.

Ability to debug inside Docker container

Now you can attach the debugger to a Java application running inside a Docker container. The IDE now allows debugging inside containers that are built from a Dockerfile or created using Docker compose (docker-compose.yml).

External resources support

IntelliJ IDEA 2019.1 supports external resources, which means you can now load a custom resource definition specification from external sources. Currently, this is only possible from local files. To add the specifications, go to Preferences/Settings | Languages & Frameworks | Kubernetes and add the path to the custom resource definition specification.

Chart rename refactoring in Helm resource files

Now it’s possible to use the Rename refactoring in the chart of the Helm resource template files. Please note that you need to install the Go template plugin to enable this support for Helm resource template files.

Option to export your Code Style settings to JSON

It’s possible to now export all your code styles settings, even if they match the default ones, to JSON from IntelliJ IDEA. Go to Preferences/Settings | Editor | Code Style and select the option ‘Export | IntelliJ IDEA code style JSON’ from the drop-down menu.

Ability to enable soft-wraps depending on file type

Soft-wraps can be limited for specific file types by going to Preferences/Settings | Editor | General and using the Soft-wrap files field.

The Keymap Configuration Dialog for the Ctrl-Y keystroke on Windows

When you first use the Ctrl+Y keystroke on Windows, the Keymap Configuration Dialog will be shown asking you to assign the shortcut to either “Delete Line” or “Redo”.

Sublime Text keymap

We have continued adding new pre-configured keymaps to IntelliJ IDEA, and with v2019.1 we’ve added the Sublime Text keymap. Go to Preferences /Settings | Keymap and from the Keymap drop-down list, choose Sublime Text – that’s it! Now you can use Sublime Text’s shortcuts in IntelliJ IDEA.

VS Code Keymap plugin

You can now use the pre-configured VS Code keymap, which we have made available as a separate plugin! Install this plugin and select the VS Code keymap in Preferences /Settings | Keymap.

Support for Java-style Lambda syntax of Groovy 3.0

IntelliJ IDEA 2019.1 supports the experimental Groovy 3.0 feature – Java-style Lambda syntax. The IDE provides editing support for it including code completion, highlighting, and type inference. The Groovy intentions and inspections will also work properly inside the lambda body. Formatting is also available for Java-style lambdas and you can debug Java-style lambdas too.

Spring Cloud Stream editing support

IntelliJ IDEA now provides rich editing support for Spring Cloud Stream projects such as syntax highlighting, inspections, quick-fixes, and code completion (including binder name completion for values and references in the application.properties or application.yml files).

Navigation between bound Producers and Consumers

You can now navigate between the bound consuming and producing message handlers using the gutter icon. Bear in mind that Consumers and Producers should be bound in the application.properties or application.yml files via the ‘spring.cloud.stream.bindings’ configuration key.

Improved Thymeleaf support

Now you can navigate to template fragments referenced in the ‘th: replace’ and ‘th: include’ attributes. Code completion and the Rename refactorings now also work for these included and replaced fragments.

Support for Greenplum, Vertica, and Apache Hive

IntelliJ IDEA supports these new databases:

• Greenplum – an analytics database based on PostgreSQL.
• Vertica – column-oriented storage designed to handle large volumes of data.
• Apache Hive – a data warehouse built on top of Apache Hadoop for providing data query and analysis.

Improved connection dialog

We’ve refreshed the look of the connection dialog and added several important settings. You can now add an SQL query in the ‘startup script’ field, which will be run each time you establish a connection. Also, you can set a timeout after which the IDE will auto-disconnect, or set up a time interval to run a query every N seconds to keep the connection alive.