IntelliJ IDEA 2020.1 adds support for Java 14 and new features for a number of frameworks, upgrades the debugger with dataflow analysis assistance, adds a new LightEdit mode, downloads and configures the JDK for you, and does so much more!
IntelliJ IDEA 2020.1 adds support for Java 14 and its new features. Not only does the IDE
add full code insight support for Records, but it also enables you to quickly create new
records and generate their constructors and components, and it warns about existing errors.
You will also discover support for Pattern Matching for the
new inspection and a quick-fix that quickly simplifies the verbose instanceof-and-cast
idioms by replacing them with the new concise pattern variables.
You no longer need to search for the necessary JDK on the web. Starting with IntelliJ IDEA 2020.1, you can download and set up a JDK build right from the IDE as you create and configure your project. If you open a downloaded project, the IDE checks whether the JDK configured for this project is already installed on your computer. If not, the IDE will prompt you to download it.
With every new version of IntelliJ IDEA, we’re extending its static code analysis
capabilities. And this release isn’t any different. Apart from a range of improvements,
we’ve also added several new code inspections. They check capitalization in the
SimpleDateFormat patterns, analyze date formatting cases, search for additional
method calls, and report and suggest eliminating unnecessary escaping characters in string
IntelliJ IDEA 2020.1 comes with the long-awaited LightEdit mode. You can now make quick modifications to standalone files in a text-like editor without creating or loading an entire project. You can open files in this new lightweight editor from the command line, the IDE’s Welcome screen, or from your OS system file manager. You can also switch from LightEdit mode to full project mode by using the “Open File in Project” intention (Alt+Enter).
When working on your Java or Kotlin app in IntelliJ IDEA 2020.1, you no longer need to use a cumbersome modal dialog to change the signature of a method or a class. Now you can simply edit the parameters of a class or a method, and then click the new gutter icon or press Alt+Enter to review and apply the changes to the class / method declaration and all of its usages.
Reading Javadocs in the editor can be annoying because of all the tags you have to wade
through, especially when you need to interact with the reference links and images. This
is why we’re adding a way to render Javadocs right in the editor. Enable this feature
Help | Find actions | Render documentation comments on file opening.
We have taken our first steps toward implementing Code Vision –
an easy way to focus on code while getting additional information about it. In IntelliJ IDEA
2020.1, Code Vision can show you the usages and implementations of Java
symbols. To enable the feature, go to
Preferences / Settings | Editor | Inlay Hints |
Code Vision, and check the related
Show hints… checkboxes.
IntelliJ IDEA 2020.1 provides one more option to simplify project navigation. You can jump
to the necessary line in a file straight away without scrolling because the navigation bar
now shows you methods in Java classes and interfaces. If you don’t use the navigation bar,
now is a great time to turn it on in
View | Appearance | Navigation Bar.
We’ve introduced the new Zen Mode for our editor. It helps you eliminate any
and focus solely on your source code. Zen mode combines Distraction Free Mode with Full
Screen Mode, so you don’t have to enable both of them anymore. Just select
Appearance | Enter Zen Mode from the main menu and forget about the world outside.
IntelliJ IDEA 2020.1 comes bundled with the Grazie plugin, which is a comprehensive grammar,
spelling, and style checking tool. Now the IDE checks more than just your code constructs.
It also helps you write clear string literals, comments, Javadocs, commit messages, and much
more in 16 natural languages. By default, it only checks text files, but we encourage you to
enable it for Java files too in
Settings/Preferences | Editor | Proofread | Grammar.
Learn the type definitions of variables, fields, methods, and other symbols without
switching focus from your code. Place the caret at the necessary symbol and select
Quick Type Definition from the main menu. IntelliJ IDEA then shows you the information
in a popup, from which you can open the source file and edit the code.
IntelliJ IDEA 2020.1 adds dataflow analysis to the JVM debugger. It predicts code
execution before this code is actually executed. When your application stops at a
breakpoint, the IDE runs dataflow analysis based on the current state of the program to
check what is going to happen next. To use DFA in the debugger, enable it in
| Build, Execution, Deployment | Debugger | Data Views | Java.
Another improvement is the ability to pin any of an object’s fields to the top of the fields list. This is handy when an object has so many fields that it’s difficult to locate the one you need to investigate.
Support for application profiling in IntelliJ IDEA keeps evolving. In this release, we’ve added several new features: Focus on Subtree, Focus on Call, Exclude Subtree, and Exclude Call. With these options, you can focus more specifically on a chosen method call and filter out the unnecessary ones.
The profiler in IntelliJ IDEA now detects recursive calls when the same method is called higher up in the stack. The IDE allows you to bypass recursion by taking these calls out of the subtree, which lets you focus on the methods that consume most of the resources and on the calls that they make. Recursive calls are marked with this new special icon in the Call Tree tab of the Profiler tool window.
IntelliJ IDEA 2020.1 opens .hprof memory dump files that can help you identify memory leaks
and find ways to optimize memory usage. For example, you will see basic information, like
the total size, number of instances, and stack traces of the file. The files also list all
root objects grouped by classes, all classes sorted by their numbers of instances or size,
and all class instances with the field value viewer. To open the .hprof file, go to
| Find action and type “hprof” to find the Open Hprof Snapshot action. Note that
this feature is in its early stages, and will be improved in the following major releases.
In IntelliJ IDEA 2020.1, we’ve reworked the interface for committing changes to your VCS
repository – instead of a modal Commit dialog, you can now take full advantage of the
dedicated Commit tool window. It provides more space for the list of modified files
and the diff, and it lets you add changes to a commit when they are ready, compose a commit
message iteratively, and choose which of the staged changes go into which commit. The new UI
is enabled by default for new users; existing users can switch to it in
| Version Control | Commit.
The reworked Interactively Rebase from Here dialog has become truly interactive. Now it does a lot more than letting you select an action you want to perform on each commit in your branch. It also features a graph showing which actions have been applied, displays commit details, and lets you see a diff and review or reset the changes if necessary.
With IntelliJ IDEA 2020.1, you no longer need to pre-install Git manually. When you clone an existing Git repository, the IDE will look for the Git executable on your machine, and will offer to download and set it up for you if the IDE can’t locate it.
We care a lot about the efficiency of IntelliJ IDEA, but we also devote a great deal of our efforts to its look and feel. Many of our users already know that we’ve recently finished developing our own font – JetBrains Mono. We’ve been getting tons of positive feedback, and that is why JetBrains Mono has become the default font of IntelliJ IDEA in this release.
IntelliJ IDEA 2020.1 features a new default light theme that is now unified across all the
different operating systems. Please welcome IntelliJ Light! You can always roll back to one
of the old themes in
View | Quick Switch Scheme | Theme, but we really encourage
to give IntelliJ Light a go.
As we always strive to keep up with the developer trends and support the most popular technologies, in v2020.1 we’ve enhanced our support for the Spring WebFlux framework. We’ve added request mappings, so if your WebFlux application has Actuator enabled, you can access the mappings in the Run tool window to monitor your application and interact with it. Also, the IDE now works properly with the Rendering API, so code autocompletion and navigating to the related views are now available. On top of that, you can take full advantage of the code insight features, such as Find Usages (Alt+F7), and the Rename refactoring (Shift+F6).
Previously, IntelliJ IDEA treated Spring profile expressions as strings. Starting with v2020.1, the IDE distinguishes between different profiles in an expression, and lets you apply smart actions to them, such as Find Usages (Alt+F7) and the Rename refactoring (Shift+F6). We’ve also enhanced the usability of the Change Active Spring Profiles popup and implemented completion for existing profiles.
IntelliJ IDEA 2020.1 Ultimate introduces initial support for Selenium, a popular framework for testing web applications, through a new Selenium UI Automation Testing plugin. The new plugin supports the most popular JVM frameworks for UI testing and reporting libraries: Selenium, Selenide, Geb, Serenity BDD, and Allure Framework.
IntelliJ IDEA’s enhancements for Selenium include a new project wizard, highlighting, inspections, and code completion in tests for Java/Kotlin/Groovy languages, validation for various configuration files, and icons in the gutter for easier navigation.
IntelliJ IDEA 2020.1 comes with a full set of code insight features for JMS and Spring Messaging APIs for both Java and Kotlin applications. These include code completion, navigation, the Rename refactoring (Shift + F7), reference injection (Alt + Enter), and more.
In the previous version of IntelliJ IDEA, we added support for the Micronaut framework. The new version extends this support and adds automatic completion for parameters in configuration files, as well as navigation and quick documentation. The IDE now also autocompletes basic data types and detects whether a value is invalid. Additionally, IntelliJ IDEA now recognizes injected RegExp fragments in Micronaut URL mappings, which makes the syntax more readable.
IntelliJ IDEA 2020.1 augments RxJava support by adding a number of useful inspections. The IDE now detects unused publishers, and lets you know when a lambda returns a null. It also highlights thread-blocking method calls and filter chains that are too long.
With IntelliJ IDEA 2020.1, you can now create new Quarkus and MicroProfile projects directly through the New Project wizard, which will walk you through the initial configuration.
The IDE now automatically injects SQL fragments for popular third-party libraries that were previously treated as usual strings, and provides code completion and navigation for SQL statements and fields. The list of supported libraries includes R2DBC, Vert.x SQL Clients, Apache Spark SQL, and Apache DB Utils, among others.
IntelliJ IDEA 2020.1 is integrated with Swagger Codegen – a powerful tool for generating server stubs, API clients, and documentation that supports a vast range of programming languages. We’ve prepared a dedicated run configuration where you can set things like a path to generate the files to, a path to the .mustache templates folder, a language, and a different JRE in case of compatibility issues. To let Swagger Codegen do its magic, you just need to open an OpenAPI/Swagger file, specify its settings, configure a few options, and then click Run.
IntelliJ IDEA 2020.1 knows how to work with openapi/swagger specifications. For example, it
provides autocompletion for them. You just need to enter the specification URL in the
settings, and the IDE will complete URL paths from it as you type. You can also create your
own specifications in the same way that you usually create classes and interfaces:
New | OpenAPI Specification.
The HTTP client in IntelliJ IDEA 2020.1 is getting a bit smarter. Now it can correctly autocomplete path variables and URL paths, and it can get you to the related endpoints right from the HTTP request files. We also have an update for our Micronaut and Spring users: request handler methods now feature a gutter icon for URL mappings. Use it to create or open an existing HTTP request file and navigate to the HTTP client.
To help you more easily pull images from a Docker registry, we’ve reworked our UI and removed the modal dialog. Now, you can simply click the Images node in the left-hand pane of the Service tool window, and IntelliJ IDEA will open the Images Console tab in the right-hand pane, from which you can easily pull images. The IDE also provides completion for images.
You can now update a Kubernetes cluster to match a state defined in your local files, by invoking the “Apply” command right from the editor gutter.
IntelliJ IDEA 2020.1 brings a small but important update to our Maven and Gradle users. Instead of the old auto-import, there’s now a floating notification in the upper-right part of the editor. Use this notification or a new shortcut (Ctrl+Shift+O for Windows and Linux /Shift+Cmd+I for Mac) to load the changes after you modify the build file. It gets even better: when IntelliJ IDEA detects any changes to the build file made outside the IDE, such as VCS updates, it reloads the related projects automatically.
Now that Dotty is destined to become Scala 3, we have started to work on full-fledged Scala 3 support. The Scala plugin now includes preliminary support for Scala 3, with the new syntax, error highlighting, navigation, type info, and many other bread-and-butter IDE features.
Because both the language and the language support are still works in progress, we recommend using nightly plugin builds if you want to get new features and bug fixes as soon as possible.
In Scala, functional literals are used a lot. They are very much like methods and have separate parameters and bodies. But they are often treated as a single expression of function type, making it harder to locate and interpret errors.
In this release, we've introduced fine-grained error highlighting for function literals, which can help you pinpoint errors relying on clear and precise messages, instead of possibly obscure messages with function types.
The Scala plugin has been able to show unused variables and methods for a long time. Now it can also spot unused parameters. Parameters that are not referenced inside a method or class are highlighted in gray.
In contrast to variables and methods, unused parameters are often the result of programming errors. So not only does the new inspection make your code cleaner, but it can also help you prevent various errors.
In Scala, we often have multiple method calls on the same line. In such cases, using Step Into in the debugger is hardly convenient – you have to manually step into and then out of many methods before you reach the desired one.
In this release, Step Into has become Smart Step Into. You can simply choose a desired method, and the IDE will do the work.
We've improved BSP support. It now works more smoothly, and with more projects and build tools. You no longer have to manually install Bloop to import sbt projects via BSP – the Scala plugin can convert such projects to Bloop format automatically. It's now possible to cancel BSP builds from the Build tool window. Finally, you can view and manage BSP connections using the BSP widget.
With out-of-the-box support for the Vuex library and the Composition API from the upcoming Vue 3, you can build great Vue.js applications even more smoothly.
The database improvements include the ability to export data to Excel (.xlsx) files, view data as text right in the editor, create run configurations, and many other things.
Check out What’s New in DataGrip for all the database improvements that are also available in IntelliJ IDEA 2020.1.
We’ve added an ability to split terminal sessions vertically or horizontally so that you can run them side by side. You can invoke the context menu from the Terminal to create, navigate, and close a split terminal session.
Starting with v2020.1, you can choose any location within your project folder for your run configurations so that you can share them with your team members through version control. To do so, open the Run/Debug Configurations dialog, check Store as project file in the upper right part of the dialog, and click the gear icon. This will open a popup which allows you to choose where to store your run configurations.
IntelliJ IDEA 2020.1 brings support for the Android Volley library. It provides automatic code completion for URL path references, and lets you navigate to related resources.