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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The New Class dialog has a new look. What’s more, now it lets you preview the types of classes you can create.
On Windows 10, the IDE now has a new modern borderless look.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
IntelliJ IDEA 2019.2 reminds you to modify the files you have usually committed before together with the files you modified recently.
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.
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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
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 annotation hints now support dynamic folding, tooltips, navigation, and brace matching. The type hints are now shown only when truly needed.
Previously, you had to use intentions to wrap (or unwrap) expressions inside curly braces. Now IntelliJ IDEA can do that automatically, as you type.
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.
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.
Now you can inject languages into multiline string literals with margins.
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.
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.
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.
The Node.JS plugin now comes pre-installed with IntelliJ IDEA Ultimate.
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).
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.
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.
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.
Now you can paste a cURL request string into the HTTP client and have the IDE automatically convert it to a full request.
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.
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.
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.
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.
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.
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.)