IntelliJ IDEA 2019.1 Early Access Program is open!

It’s time to get started on the Early Access Program for IntelliJ IDEA 2019.1 and to shed some light on what the next major update has coming your way! To kick it off, we have some new and improved Java refactorings, support for Java 12 Enhanced Switches, Gradle improvements, Spring Cloud Stream refinements, various VCS goodies, and much more.

kGzvjgSj

Java

Java 12 Enhanced Switches support

The upcoming IntelliJ IDEA 2019.1, brings support for the Java 12 Preview feature – Enhanced Switches JEP 325. We have a number of new inspections and quick-fixes to get you started.

When you set the language level to Java 12 Preview, the IDE detects any ‘switch’ statements that can be replaced with the enhanced ‘switch’ statement or expression. The IDE highlights any such ‘switch’ statements and provides a quick-fix for the conversion.

Java12OldToNew

IntelliJ IDEA can already generate missing switch branches for an enum, but with this upcoming release, we have expanded this ability to make it also work for enhanced switch statements and switch expressions.

If a switch expression over enum lacks an enum constant and a default branch, such code is incorrect, according to JEP 325. IntelliJ IDEA detects such cases and suggests a fix for them by inserting the missing constant branches or default branch.

Java12CreateMissingBranch

The IDE will detect duplicate branches in ‘switch’ and offer a quick fix to merge them.

Java12MergeDuplicates

We plan to publish a post dedicated to explaining the enhanced switches support in IntelliJ IDEA in even more detail, so stay tuned!

Extract variable refactoring enhancements

With this upcoming release, we’ve taken a long hard look at the refactoring and worked on enhancing the “extract variable” refactoring, so it preserves semantics even better than before.

Now the IDE can extract a variable even from the field initializer, and within this refactoring, it can automatically move the initializer into an initializer block.

JavaExtractVariableFieldInitializer

The extract variable refactoring can now convert a ternary to an ‘if’ statement automatically for the condition is important. For now, it works for return, assignment, and declaration.

JavaRefactoring

Also, now IntelliJ IDEA provides you with the ability to configure variable names for auto-generated try/catch blocks. You can configure a final modifier, name, or even the type of exception in the Preferences / Settings | Editor | File and Code Templates.

JavaConfigureVariable

Gradle

Now you can get the best of both worlds – the natural Gradle behavior for packaging, building, and running your project, and useful IDE features such as HotSwap for classes and resources. While we have been preparing this improvement, we have fixed a number of bugs and usability issues with Gradle integration, so now having dealt with these working with Gradle projects in IntelliJ IDEA is a much more enjoyable experience.

Delegate build/run to Gradle is enabled by default for new projects
In the upcoming IntelliJ IDEA 2019.1, the build and run actions are delegated to Gradle by default for any new project.

The delegation of build and run actions to Gradle can be set for each Gradle project
You can delegate build and run actions to Gradle for each project individually. Previously, when the “Delegate IDE build/run actions to Gradle” option was enabled, it was applied to all projects.

image13

To delegate run/build actions to Gradle for specific projects only, go to Preferences / Settings | Build, Execution, Deployment | Build Tools | Gradle and in the ‘Build and run using’ dropdown menu select the Gradle option. You can even configure this option for each Gradle project if your IntelliJ IDEA project consists of several Gradle projects. It is also possible to set different values for the test runner and the application runner for the same project.

HotSwap works when build actions are delegated to Gradle

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

‘gradle-idea-ext-plugin’ enhancements

If you ever use the ‘gradle-idea-ext-plugin’ plugin to create or update an IntelliJ-based project, then we have some good news for you. Now it’s possible to set up the package prefixes for Gradle projects with this script, and you can configure the default encoding using the build script. Learn more here.

Miscellaneous Gradle improvements

And that’s not all; we’ve also upgraded the built-in Gradle to v4.10.3. This makes it possible to run JUnit parameterized tests using the Gradle test runner. And not to mention the Gradle Tool Window now displays the structure of a multi-module project, the same way as it would if you were to run the ‘gradle projects’ command.

Maven

The Maven support in IntelliJ IDEA in this release has also had some improvements made to it. For a start, when build actions are delegated to Maven, the HotSwap works.

The <release> option of the maven-compiler-plugin has a higher priority than the <source> and <target> options. And when the parent project defines the <source> and <target> options, these properties are overridden by IntelliJ IDEA with the <release> property from the pom.xml file.

Please note, that we don’t bundle Maven 2 with IntelliJ IDEA anymore, the only bundled Maven version now is v3.3.9. The forthcoming IntelliJ IDEA v2019.1 still supports Maven 2; you will just need to install it locally if you want to continue using it.

We are considering ending support for Maven 2 in v2019.2; please let us know your thoughts or suggestions about this decision. We want to make sure that Maven support in IntelliJ IDEA will continue to meet your needs.

Version Control Systems

Fixup and Squash actions were added to VCS log

In the upcoming IntelliJ IDEA 2019.1, you can invoke Fixup and Squash actions from the context menu of the VCS Log tab. These actions help to create commits with the correct fixup! and squash! commit messages.

image16

Cherry-pick a file from a commit from the VCS log

With the upcoming IntelliJ IDEA 2019.1, you will be able to cherry-pick select files from the commit right from the context menu in the VCS log.

image11

The indication of incoming and outgoing commits

The IDE now indicates if the incoming and outgoing commits are available for individual branches in the Branches popup, just enable the new ‘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

With the upcoming IntelliJ IDEA 2019.1, you are able to undo the deletion of the shelved files. There is a separate new “Recently Deleted” node in the Shelf tree where you can view all the recently deleted files and restore any useful shelved files, that have been deleted by accident.

image2

Mode to view author initials for VCS annotations

The IDE can show 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.

image8

SSH executable selector has been removed from the Git Settings

Previously IntelliJ IDEA provided two SSH executables for Git – Built-in and Native. The only reason to use Built-in instead of Native was that the IDE could not handle interactive prompts from Native SSH. In all other aspects, Native is better than Built-in as it supports more features, security protocols, and keys. The issue with interactive prompts was fixed in v2018.3, and now Native is the default and recommended SSH executable to use. The Native SSH executable works in almost every case, and now there is no need to additionally set it.

Please note that on Windows, Git 2.4 is the earliest supported version. (As “Native SSH” doesn’t work with 1.9 ‘msys’ executables).

File Status Highlights for the ignored files and folders

In the Project view, the ignored files and folders are marked with an olive color, so now you can distinguish all the ignored files and packages from any other files, at a glance.

VCSFileStatusHighlights

Diff Viewer

The diff viewer can now show the difference by char unit and not only by the word unit as it was before. This could be pretty useful if your source code has any lines of characters from different alphabets, for example Japanese.

image4

Editor
The Keymap Configuration Dialog for the Ctrl+Y keystroke

Starting from v2019.1, on the first usage of the Ctrl+Y keystroke for new users, the Keymap Configuration Dialog will be shown, providing you with the option to assign the shortcut to the “Delete Line” or the “Redo” action. If you change your mind later, you can always change it again in Settings | Keymap.

On Windows, for as long as we can remember, the Ctrl+Y shortcut was assigned to “Delete Line” in the default Windows keymap. This appears to be confusing many of our users since in many text editors the Ctrl + Y shortcut is assigned to “Redo”. Because “Ctrl+Y” was mapped to “Delete Line” for a very long time already in IntelliJ Platform, we’re not ready to fully remap Ctrl+Y to the “Redo” action or remove the default mapping, as we don’t want to break the habits and processes of our current users who have gotten used to this.

Spring Cloud Stream

With IntelliJ IDEA 2018.3, we added initial support for Spring Cloud Stream, and with the upcoming v2019.1, we’ve taken this support even further.

IntelliJ IDEA now provides rich editing support: syntax highlighting, code completion, inspections, and quick-fixes for Spring Cloud Stream projects.

SpringCloudStreamCompletion

Binder name completion in application configuration files

Also, now the IDE provides the binder name completion for values and references in the application.properties or application.yml files.

SpringCloudStream

Navigation between bound Producers and Consumers

IntelliJ IDEA provides navigation between the bound consuming and producing message handlers via the gutter icon. Producer and Consumer methods can be annotated with either Spring Integration annotations or Spring Cloud Stream native annotations. Please note that Consumers and Producers should be bound in the application.properties or application.yml files via the ‘spring.cloud.stream.bindings’ configuration key
(e.g. spring.cloud.stream.bindings.input.destination=testtock).

SpringCloudStreamNavigationProducerConsumer

Aside from all this, we’ve updated the OSGI framework support in IntelliJ IDEA and now the updated Concierge framework is supported.

The global menu support on Linux is not an experimental feature anymore; it’s now fully supported in IntelliJ IDEA.

The plugin settings are searchable in IntelliJ IDEA. Even if a plugin is not bundled with the IDE and just installed manually, the settings will still appear in a search result.

We’ve updated the JBR version to 1.8.0_152-release-1402-b1. With this new JBR version, among other issues we’ve fixed an issue that caused the IDEs window go to the background when the breakpoint was hit.

With this upcoming version, we’ve fixed more than 900 issues – various bugs, performance problems, and usability issues! You can find the full list of all the issues we have addressed in the IDE and JBR release notes. We want to thank you all for the feedback that you keep sharing with us! We really appreciate it and we always look forward hearing your thoughts and suggestions, so please leave a comment below, create an issue in our issue tracker, or tweet us!

That’s it! It’s time to give it a test and provide some feedback – download the first EAP build of IntelliJ IDEA 2019.1 right away from our website or via Toolbox App.

Happy developing!

About Zlata Kalyuzhnaya

IntelliJ IDEA Marketing Manager at JetBrains. twitter: @ZlataKalyuzhnay ‏
This entry was posted in EAP Releases and tagged , . Bookmark the permalink.

22 Responses to IntelliJ IDEA 2019.1 Early Access Program is open!

  1. Edoardo Luppi says:

    Yeah! I’ve been trying it out since a couple of hours and it runs smoothly.
    I’ve seen a couple of exception thrown, but it’s understandable.

    Will the JavaScript/TypeScript new features be highlighted in the WebStorm blog? I’m curious on those too!

  2. Edoardo Luppi says:

    Oh, thanks!

  3. Edward Drapkin says:

    I updated to the latest EAP and my font rendering is completely broken, like the anti-aliasing is no longer being applied: https://i.imgur.com/9pGBP4o.png

    Absolutely a deal breaker, going back to a 2018 version, and hopefully this will be fixed in the next release. One of the rare times when it’s not a hyperbole to say that this error makes the IDE literally unusable.

  4. Nicholas Quezada says:

    Best IDE ever. Love you guys!

  5. Gitman says:

    With so easy to access fixup and squash options I will soon forget every git command and become a peasant UI user who will open IDEA just to use it as a git client. Damn you!

  6. John Long says:

    Do NOT drop support for Maven 2! Enterprise companies can be very, very slow to adopt newer technologies, and the last thing those struggling to make things better at those companies need is to lose the support of the IDE that makes things livable.

    • Edoardo Luppi says:

      Agree. But seems you’re safe for this year :)

    • Bric3 says:

      Then why would it be needed to update to newer versions of IntelliJ if it is to be used with decade old technology (almost, maven 3 was released in 2010), let’s stick with older version of IJ that are in phase with this. I’m not trolling. Current versions of IJ works quite well, if the current stack you are working on is aligned with what IJ offers there’s no reasons to prevent IJ to drop support.

  7. Niko Strijbol says:

    Does anyone know which version of Android Studio is included in Intellij?

    Other than that, very nice release!

  8. Dmitry says:

    Hi,

    Today’s EAP has a “bundled JDK 11” download option. What would be the benefits of using it instead of “bundled JDK 8” one?

    I see that JDK 11 archive includes only jre64 (i.e. no jre32). Yet it is 80 MB larger than JDK 8 one. Isn’t JDK 11 package supposed to be smaller? (thanks to excluding unused modules)

    • Tom Prodehl says:

      The bundles JDK 11 includes all the modules and the jar files so you might be able to build JPMS-based reduced executables OR continue to use your Grandpa’s jar files and CLASSPATH. At least in theory, I hear there is still some work going on after all.

    • G says:

      It’s not the JDK that gets smaller, it’s the JRE you bundle with your applicaiton, with usage of jlink. Jetbrains can’t really do that for the IDE, though, since they can’t limit what’s available to plugins.

  9. v says:

    “we’ve also upgraded the built-in Gradle to v4.10.3”

    We such an old version? Current Gradle is 5.1.1

    • Nikita Skvortsov says:

      Hi,

      The update was performed before Gradle 5.0 was available, using latest stable version.
      Also, bundled version does not limit you to using only it with your project. IDEA fully supports Gradle 5.1.1 and even some features of not yet released 5.2

      Do you have any specific issues with version 4.10.3 ?

  10. Alfonso Fernandez says:

    Updated this morning and now I can’t use this. I am getting a error on pluginmanager.

    https://docs.google.com/document/d/1zvUSf-1hSlBwaYSIHdUpxID-psQwRPTl1qeywQ8vJ-s/edit?usp=sharing

  11. heep says:

    Without option SSH executable ‘Native’ on git configuration git from IntelliJ on MAC wan’t work. From command line works just fine but not from IntelliJ.

    • Dmitriy Smirnov says:

      Native is default since 2018.3. It is still the default in 2019.1.
      Nothing was changed, just a selector that allows switching to outdated built-in client was removed.

      Most likely SSH does not work due to some misconfiguration. Please submit a request to https://youtrack.jetbrains.com/issues/IDEA with details – how is SSH setup, what exactly is not working, etc.

Leave a Reply

Your email address will not be published. Required fields are marked *