IntelliJ IDEA 2020.1

Java

• Java 14 Support: Records and Pattern Matching - 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 instanceof operator including a new inspection and a quick-fix that quickly simplifies the verbose instanceof-and-cast idioms by replacing them with the new concise pattern variables.
• Download the JDK from the IDE - 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.
• New Java inspections - With every new version of IntelliJ IDEA extends its static code analysis capabilities. And this release isn’t any different. Apart from a range of improvements, this release also adds several new code inspections. They check capitalization in the SimpleDateFormat patterns, analyze date formatting cases, search for additional redundant method calls, and report and suggest eliminating unnecessary escaping characters in string literals.

Editor

• LightEdit Mode - 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.
• In-place Rename and Change Signature - 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.
• In-editor Javadocs rendering - 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 this version adds a way to render Javadocs right in the editor.
• Quick type definition - 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 View | 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.
• Improved navigation bar - 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.
• Zen mode - Introduced the new Zen Mode for the editor. It helps you eliminate any distractions 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.
• Smart Grammar and Spell Checker - 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.

Debugger

• Dataflow analysis assistance - 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.
• Pin to top - 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.

Profiler

• Focus on method calls - Support for application profiling in IntelliJ IDEA keeps evolving. This release adds 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.
• Collapse recursive calls - 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.
• Initial support for HProf snapshots - 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 Help | 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.

Version Control

• New Commit tool window - IntelliJ IDEA 2020.1 reworks 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.
• New Interactively Rebase dialog - 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.
• Install Git from the IDE - 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.
• Branches popup
  • The Branches popup now features an explicit search field that enables you to look for existing remote and local branches.
  • The Refresh button has been reworked, so that you can now use it to update the existing remote branches.
  • Incoming (blue) and outgoing (green) commit indicators have been added to the status bar.
  • The Log now features a branches list.

UI

• JetBrains Mono - JetBrains Mono has become the default font of IntelliJ IDEA in this release.
• Unified IntelliJ Light theme - IntelliJ IDEA 2020.1 features a new default light theme that is now unified across all the different operating systems.

Frameworks and Technologies

• Spring WebFlux - v2020.1 enhances support for the Spring WebFlux framework. 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).
• Spring profiles - 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). Also enhanced the usability of the Change Active Spring Profiles popup and implemented completion for existing profiles.
• Selenium - 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.
• JMS and Spring Messaging APIs Ultimate - 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.
• Micronaut - In the previous version of IntelliJ IDEA, 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.
• RxJava - 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.
• Quarkus and MicroProfile - 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.
• Injections for third-party SQL libraries - 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.
• Swagger Codegen - 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. This release prepares 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.
• Remote specifications - 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.

HTTP Client

• Improved autocompletion, and more - The HTTP client in IntelliJ IDEA 2020.1 is 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. Also includes an update for Spring users: Spring MVC 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.

Docker

• Easier Pull workflow for Docker - To help you more easily pull images from a Docker registry, this release reworks the 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.

Kubernetes

• Apply command for Kubernetes files - 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.

Build tools

• Maven and Gradle importing updates - IntelliJ IDEA 2020.1 brings a small but important update to 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.

Scala

• 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.
• Fine-grained error highlighting for function literals - 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. This release introduces 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.
• Unused Parameter inspection - 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.
• Smart Step Into - In Scala, you 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.
• BSP support improvements - 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.

JavaScript

• New smart intentions and inspections - New smart intentions and inspections (Alt+Enter) enable you to save yourself some time when coding. For example, you can now quickly convert the existing code to optional chaining and/or nullish coalescing, the syntax introduced in the latest versions of JavaScript and TypeScript.
• Vuex and Composition API support - 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.

Database improvements

• 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.

Terminal

• Split terminal sessions - 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.

Run Configurations

• Store Run Configurations as files - Starting with v2020.1, you can choose any location within your project folder for your run configurations. 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.

Android

• Android Volley support - 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.

Other

• IntelliJ-based IDEs have fully switched from JetBrains Runtime 8 (JBR8) to JetBrains Runtime 11 (JBR11).
• IDE settings are now automatically imported from one major version to another.