2018.1 Mar 27


Enhancements in code completion

Completion in the Stream API chains is now aware of type casting. Code completion can not only suggest a completion item according to the existing call filter (String.class::isInstance), but also for an automatically typecast completion item.

Data flow analysis

We’ve improved our data flow analysis so it can now track the relationships between variables like “greater than” and “less than.” The IDE detects when a condition is always true (or false) in all the possible code paths when the variables are compared.

The IDE will now warn you when you try to assign a variable to the same value it already contains. This may help you detect and then remove some redundant code.

The data flow analysis now works for non-terminated stream API chains.

The IDE will also warn you about modifications to immutable collections.

learn more

Missing ServiceLoader declaration

IntelliJ IDEA 2018.1 has new Java 9 inspections and quick-fixes. The IDE now checks that a service loaded by ServiceLoader is declared in the module-info.java file, and will offer a quick-fix to add a missing statement to the module-info.java file.

learn more

Creating missing class

For an unresolved class mentioned in module-info.java, the IDE will suggest creating the missing class, and create missing exported packages as well. Note the IDE creates the package with the class in the required directory, as you can’t export an empty package in Java 9.

Idempotent body detection

The IDE will detect and warn you about the while-loops with an idempotent body, as in most cases this indicates a programming error and can lead to a program hang.

Move break-condition of infinite loop to loop condition

For while-loops, now you get a notification about a conditional break at the end or beginning of an infinite loop. The IDE will suggest moving a break condition to a loop condition and offer a quick-fix to modify your loop. Usually replacing a conditional break with a loop condition makes the code clearer.

Explicitly redundant close() call

IntelliJ IDEA now detects an explicitly redundant close() call of the resource at the end of a try-with-resources block.

Infinite Stream detection

IntelliJ IDEA will warn you about any infinite streams that weren’t short-circuited, as such operations can be completed only by throwing an exception. Such code may result in an infinite loop or a running out of memory issue.

Copy constructor with missing fields detection

In IntelliJ IDEA 2018.1 you’ll get a notification if there is a copy constructor that doesn’t copy all the fields in a class. The IDE considers fields with a transient modifier unnecessary to copy.

Sort array content

A new Sort content action is available in array initializers and varargs. This new action sorts content alphabetically.

User Postfix Completion template

The postfix code completion has been improved. The IDE now lets you create your own Java templates or edit and rename some of the predefined Java templates through Preferences | Editor | General | Postfix Completion.

Fix partially in Inspection Results

A new Fix partially button has been added to the right-hand pane of the Inspection Results Tool Window. It appears when you have several options for fixing possible problems in the chosen scope. All the suggested quick-fixes are grouped by the quick-fix type under the Fix partially button. This new feature allows you to apply the required quick-fix to the chosen scope, and fix all affected cases in one go.

Test prefix in Code Generation

In IntelliJ IDEA you can generate a test class using the intention action. With IntelliJ IDEA 2018.1, you can customize a test class template and create a test class with Test as a prefix. Go to Preferences | Editor | Code Style | Java | Code Generation, and choose how the test class name should be generated. By default, the IDE creates a test class with the Test as a suffix.

JUnit 5 @Tag annotation support

IntelliJ IDEA 2018.1 now supports the JUnit5 @Tag annotation so now you can include tagged classes and tagged methods, in the testing scope. Select the Tags (JUnit 5) option in the test kind field in the Run/Debug Configuration dialog. Use the Uniqueld field to filter tests according to their id.

JVM Debugger

Throw Exception

IntelliJ IDEA 2018.1 has a new Throw Exception action that allows you to throw an exception from a certain location in your program without changing the code. It is available from the Run | Throw Exception menu, or from the frame context menu during a debugging session.

Logging stacktrace to console

The IDE now allows you to print breakpoints stack traces to the console. You can enable the stack trace option in the Breakpoints dialog box. In IntelliJ IDEA, you can now observe multiple breakpoints stack traces at the same time in the Console log.

Copy current thread stacktrace

You can now copy the current thread stack trace via a new Copy Stack action which is available from the frame context menu.

Annotations for Async stack traces

With IntelliJ IDEA 2018.1 we’ve extended the Async stack traces feature so that you can now use the @Async.Schedule and @Async.Execute annotations to set up capture points that are not included in the default configuration. You just need to add Maven artifact as a dependency.

Java Compiler

There is a new Use --release option for cross-compilation (Java 9 and later) checkbox on the Java Compiler page at Preferences | Build, Execution, Deployment | Compiler | Java Compiler that is enabled by default. When you need to use the --source and --target options with Java 9 and link against Java 9 classes at the same time, you can disable this checkbox.

You can also use a specific version of the ECJ compiler. Select Eclipse from the Use Compiler drop-down menu, and specify the path to jar with the chosen compiler.


Folded code highlighting

If any issues have been detected in your code, now you can find them quicker than before. The IDE now highlights the folded code regions that contain errors or warnings, and colors such blocks according to their validation status.

Highlights the folded code regions with the search results

The IDE also highlights folded code regions if they contain any matches when you search through the current file.

Inline external annotations

In IntelliJ IDEA you can annotate your code with external annotations even when direct annotation of the source code is not possible (library classes). You can configure your annotations in the annotations.xml files, which are stored outside of your source code. Previously the IDE only showed the @ icon in the gutter near the externally annotated code; now the IDE shows these external annotations inline in your code.

Inferred Annotation Hints

IntelliJ IDEA now lets you view the automatic inferences of @NotNull or @Nullable annotations right in your source code (not only in the gutter icon near the inferred annotation, as it was before). You can enable the Show inferred annotations inline checkbox in the Preferences | Editor | General | Appearance.

Project Configuration

Add “provided” dependencies to classpath

A new Include dependencies with “Provided” scope checkbox has been added in the Run/Debug Configurations for the Application and Spring Boot configurations. This new option will be useful if you have the provided dependencies for the scope in your project, but you run your application both inside a container (where provided dependencies are supplied by the container) and outside a container (where provided dependencies are not automatically supplied).

For the Spring Boot applications, the Include dependencies with “Provided” scope option is enabled by default.

New Change Module Names... action

With IntelliJ IDEA, you can now change qualified names for multiple modules all at once. This is done via the new Change Module Names… action, from the context menu of the Project Structure dialog.

Search and Replace

Structural Search enhancement

With IntelliJ IDEA 2018.1, you can find method calls to annotated methods using Structural Search. You can select them from the existing search templates or create your own.

Replace in Path improvements

IntelliJ IDEA 2018.1 has the ability to preview a regex replacement in the Replace in Path dialog.


The Kotlin plugin bundled with the IDE has been updated to Kotlin 1.2.30

Pasting Kotlin code into a package

Now, in the Project Tool Window, you can paste a code fragment directly into a package, and the IDE will create a new Kotlin file with the pasted code.

Intentions for converting the scoping function calls

The Kotlin Plugin now offers new intentions that convert the scoping function calls let and run into each other, as well as also into apply and vice versa.


New Convert to @CompileStatic refactoring action

Now you have a new action that’s very useful when you want to keep your code in Groovy and at the same time benefit from static compilation. To save you a lot of time migrating from existing Groovy code, this new refactoring annotates every groovy class in the scope with the @CompileStatic annotation.

This new refactoring action is available from the context menu Refactor | Convert to @CompileStatic.

learn more

Unnecessary import alias

IntelliJ IDEA 2018.1 reports unnecessary import alias for Groovy files. This new warning also works on static imports.


Inline hints

The editor can now show inline hints for parameter names, method result types, and variable types. You can also easily use the settings to customize when such a hint should be shown.

Structure View improvement

The Structure View now shows much more information about code. It displays final, abstract and access modifiers, nested definitions, primary constructor types, case class parameters as members, etc. The Structure View also provides you with an option to show all inherited members with their original class.

Refactoring: Inline function parameters

The refactoring is now capable of inlining functions with parameters. It correctly substitutes them with actual values.


IntelliJ IDEA 2018.1 merges the changes from Android Studio 3.0 and includes dozens of new features, with the following major new ones

Layout Editor improvements

The Layout Editor has been improved: there is a new toolbar layout and icons, updated layouts in the component tree, a new error panel, and more.

Brand new profiling tools

IntelliJ IDEA 2018.1 now includes Android Profiler, a brand new suite of profiling tools that provide real-time data for your app’s CPU, memory, and network activity.

Device File Explorer Tool Window

The new Device File Explorer Tool Window displays the file and directory structure of your Android device or emulator. Use this tool window to view, copy, and delete files on an Android device. You can access it through View | Tool Windows | Device File Explorer.

Build Instant Apps

The IDE now supports the ability to build Instant Apps – lightweight Android apps that can be run without installation. To start building Instant Apps, make sure that the Instant Apps Development SDK is installed. You can check which SDK tools are installed in Preferences | Appearance & Behavior | System Settings | Android SDK in the SDK tab.

Spring Boot

Access HTTP request mappings from the editor via the new REST client

Now, after you run a Spring Boot web application, a new icon is shown in the gutter for methods with @RequestMapping annotations that handle incoming HTTP requests. Click this gutter icon to open all the mappings in a scratch file with an .http extension and perform an HTTP request in the editor via the new REST client.

For methods with @GetMapping annotations, you have the choice to open the mapped URLs in a browser, or open a request in the HTTP Request Editor.

Note, that you need to add the dependency for the spring-boot-starter-actuator to your pom.xml or build.gradle file.

New gutter icons for beans registered in the application context

IntelliJ IDEA shows all the beans that are registered in the application context in the Beans tab in the Run Dashboard (or in the Run Tool Window). We’ve extended this functionality, and now this information is also available in the editor. The new gutter icons are shown next to the beans that are used at runtime.

Click these new gutter icons to navigate to the dependent beans.

Version Control

Partial Git commits

IntelliJ IDEA 2018.1 supports partial Git commits (git add -p). The IDE lets you associate the code chunks with a changelist. Create a changelist, put all the needed code chunks there, and then commit it. The IDE will now only commit the selected changes from the file and will skip all other changes. To add the code chunks to a commit, use the checkboxes in the gutter in the Diff pane of the Commit Changes dialog.

To move the code chunks between changelists, use the Move to Another Changelist... action from the context menu of the Diff pane in the Commit Changes dialog.

Alternatively, add code chunks to a changelist from the editor by clicking on a change marker in the gutter.

Toggle grouping of local changes by directory, module, or repository

With IntelliJ IDEA 2018.1, you can choose how to display your local changes by grouping them according to their directory, module, or repository. Use the new Group by icon available in the Local Changes tab in the Version Control Tool Window. Note that now you can select one of the grouping options or all three at once if needed.

Navigate by clicking on the commit hash

In the Log tab inside the commit detail panes, the IDE now highlights hashes of the commits you are referring to. By simply clicking commit hashes you can jump to that commit in the Log tab. This works for Git and Mercurial. Also, the Commit Details pane of the Log tab has been redesigned

History for revision tab enhancement

IntelliJ IDEA lets you view detailed information about file changes by invoking the Show History for a Revision action on a file in the Log tab (available for Git integration). In 2018.1, we’ve updated the History for revision tab so that now it works much faster. In addition to better performance, this tab has a refreshed UI resembling the Log tab.

Clone Repository

Moreover, the Clone Repository dialogs for Git and GitHub have been merged into one.

Autocompletion for GitHub repositories also works in the new Clone Repository dialog. You just need to log in to your GitHub account by clicking Log in to GitHub.

New shortcut for the Commit and Push… action

The IDE has a new default shortcut to perform the Commit and Push… action from the Commit Changes dialog. Please use Alt + Cmd + K (on macOS) or Alt + Ctrl + K (on Windows and Linux).

Git Branches pop-up

The Abort Rebase, Continue Rebase, and Skip Commit actions are now available from the Git Branches pop-up if there is an ongoing rebase process.

User Interface

New documentation UI

We’ve updated the Quick Documentation pop-up and made it clearer and more compact. Information about the method’s parameters, type, and return type is now available for Java, JavaScript, and TypeScript in the updated Quick Documentation pop-up

Better HiDPI support

When you run the IntelliJ IDEA 2018.1 on Windows 8.1 (or higher), the IDE starts in per-monitor DPI-aware mode, with implemented support for the fractional scale factors of the monitor. Previously only integral scale factors were supported in the IDE. To switch back to the default mode, you need to set-up the VM option -Dsun.java2d.uiScale.enabled = false

JavaScript & TypeScript

TypeScript improvements

IntelliJ IDEA now supports the latest TypeScript 2.7 features, improves the Implement Members action, and adds the new Surround with type guard quick-fix for unresolved properties.

Create a new Vue project

With the Vue.js plugin installed in IntelliJ IDEA, you can use Vue CLI, an official tool for scaffolding Vue apps, to create new Vue projects. To install Vue CLI, run npm install --g vue-cli in the terminal.

Reformat with Prettier

IntelliJ IDEA supports Prettier, an opinionated code formatter via Prettier plugin. After you have the prettier package installed, the new Reformat with Prettier action will become available in IntelliJ IDEA. You can format the selected code, a file, or a whole directory using Prettier.


Hunspell dictionary support

The Hunspell plugin that provides Hunspell dictionary support is now compatible with IntelliJ IDEA. Compared to a plain list of words, Hunspell provides significantly faster and much more accurate misprint detection, with far fewer false positives.

learn more


Enhancement in Docker compose

The Docker plugin now supports Multiple Docker Compose files and respects not only a docker-compose.yml but also an optional docker-compose.override.yml file. You can add docker-compose.override.yml as you would any other override file, right after the base configuration file.

Docker compose services

The Docker plugin allows you to choose the services to run just after choosing the configuration files in the Docker-compose run configuration.

The plugin shows all the existing Compose projects, not only the ones deployed via the Docker-Compose run configuration.


Support for YAML Kubernetes resource files

The brand new Kubernetes plugin supports the Kubernetes resource files from v1.5 up to the recently released v1.9. The new plugin will look for the presence of apiVersion and other fields of this kind in the files, and if these are present, it will consider such files as Kubernetes resource files.

learn more

Completion in YAML Kubernetes resource files

To help you really quickly create the required YAML definition file for Kubernetes, start typing the required key and invoke Smart Completion. The new plugin will auto-complete all the required keys from all the levels below.

Code completion now works for YAML Kubernetes resource files. The Kubernetes plugin offers the correct values you can use within the resources.

Kubernetes Live Template

The Kubernetes plugin has a built-in Live Template that allows you to quickly create the type of YAML Kubernetes resource file that you need. The new plugin now contains several predefined Kubernetes templates, and you can invoke the necessary Live Template by typing its abbreviation.

Navigation in YAML Kubernetes files

Use gutter icons to quickly navigate between a label definition and a label selector.

Jump from a label selector to a label definition inside the editor if there is a direct match for a label, both for the key and for the value.

Inspections for YAML Kubernetes files

The Kubernetes plugin will alert you whenever you select deprecated Kubernetes properties.

Also, you’ll get a warning for YAML files if you try to use properties that are not applicable for the specified elements with the applied apiVersion and kind of field.

Quick-fixes for YAML Kubernetes files

The plugin highlights elements with missing keys in YAML Kubernetes resource definition files and provides a quick-fix to add the required keys.

Also, you'll get a warning about redundant keys. Use the provided quick-fix to remove redundant keys in YAML Kubernetes resource files.

The new plugin also detects non-editable keys in YAML Kubernetes resource files and highlights them in the editor. Note that there’s an easy way to remove all such read-only keys from the current YAML file – with a handy quick-fix.

Support for JSON Kubernetes resource files

The new plugin provides some support for JSON Kubernetes resource files based on the JSON schema functionality.

Code completion and the Quick Documentation Popup are also available for JSON Kubernetes resource files.

Inspections for JSON Kubernetes resource files

The new Kubernetes plugin validates the current keys according to the JSON schema and alerts you when incorrect properties or values are used.

Also, the plugin highlights elements with any missing required properties and then advises you about the appropriate properties that should be added.

Duplicated properties are also detected in JSON Kubernetes files.

2017.3 Nov 30


Chain completion aware of type casts

Smart Completion is getting better with each release. In IntelliJ IDEA 2017.3, it is now aware of type casts and uses them to suggest chains of method calls.

Inference of nullability annotations for parameters

We’ve improved the way nullability annotations are inferred. Earlier, annotations were only inferred for library methods’ parameters and for any methods’ return types. Now we can also infer nullability annotations for the parameters of static, final and private methods.

Nullability checks for Stream API call chains

IntelliJ IDEA 2017.3 now detects possible nullability issues even in Stream API call chains.

Quick-fix to explicitly declare the inferred annotation

The IDE shows the inferred annotations in the Parameter Info and Quick Doc popups. When the caret is placed on such parameter, the IDE offers a quick-fix to explicitly declare the inferred annotation.

Support for JUnit5

IntelliJ IDEA 2017.3 provides inspections and quick-fixes to make it even easier for you to migrate your JUnit 4 tests to JUnit 5.

There is no need anymore to add additional dependencies as stated in JUnit 5 User Guide.

The following JARs will be downloaded automatically based on the API version used in the project:

  • org.junit.platform:junit-platform-launcher
  • org.junit.jupiter:junit-jupiter-engine
  • org.junit.vintage:junit-vintage-engine

Replacing StringBuilder with a Stream API call chain

StringBuilder can now be replaced with Stream.collect and Collectors.joining.

Invert boolean method quick-fix

IntelliJ IDEA detects different code inefficiencies, such as the Invert boolean method inspection. If a method was only used in an inverted way, it will be highlighted and a quick-fix will be suggested. In IntelliJ IDEA 2017.3, this inspection is performed on the fly.

Separate method calls on collections and Stream API call chains

Now, where it makes sense, the IDE suggests merging separate calls of the sort and toArray methods on collections with the Stream API call chains.

Detecting duplicate Map keys and Set elements

The IDE now detects duplicate Map keys and duplicated Set elements.

Detecting redundant throws declarations

Redundant throws declarations can now be detected on the fly.

Quick-fix for replacing deprecated code

The IDE now suggests a quick-fix for deprecated code if there is a replacement method in the JavaDoc.

Unroll loop

A new intention action unrolls a loop over an explicit list of values.

Run Dashboard supports any Run Configurations

The IDE now lets you add different types of run configurations to the Run Dashboard.

The Run Dashboard toolbar lets you rerun, stop, pause, or terminate an application. The right-hand side shows application-specific information.

Command line shortener

IntelliJ IDEA 2017.3 introduces a configurable command line shortener – a convenient new way to specify a method used to shorten the command line for each configuration.

You can set a default way to shorten the command line and use it as a template for your future configurations. IntelliJ IDEA 2017.3 also lets you share your configuration with your colleagues.

You can also preview the full command line if a long classpath was shortened via the temporary classpath.jar (the JAR Manifest option in the Run/Debug Configuration dialog).

learn more

JVM debugger

New Overhead tab

There’s a new Overhead tab in the Debugger tool window. It displays the overhead added either when stepping over the code or when the Data Renderers evaluate values to display them in Variables, Watches, or other places.

When it isn’t needed, the tab can be easily hidden and then restored again later.

On-demand Data Renderers

A new On-demand Data Renderers feature helps to reduce overhead. Now, the evaluation of values in Variables, Watches, and other places can be done on demand. Simply click on them when needed, instead of having them evaluated automatically.

Mute Renderers

To enable the On-Demand setting for the selected renderer, choose the Mute Renderers option from the context menu.

Improvements for Async Stacktraces

In IntelliJ IDEA 2017.3 the Async Stacktraces feature causes very low overhead and works out of the box, as the common capture points are built-in.

Java Stream Debugger

The Java Stream Debugger plugin, which visualizes the Java Stream operations, is built into IntelliJ IDEA 2017.3. The new functionality is available inside the Debugger tool window (click the Trace Current Stream Chain button). This plugin evaluates the current data stream and presents a visual representation of what exactly happens to each element, from the first call to the last.

Java EE 8

The long-awaited Java EE 8 is here, and it adds many new capabilities to the platform: Multiple CDI enhancements, including support for asynchronous events, HTTP/2 support in Servlet 4.0, and more. IntelliJ IDEA 2017.3 expands support for key features of Java EE 8. Learn more.

Asynchronous CDI Events

IntelliJ IDEA 2017.3 supports Asynchronous CDI Events allowing you to easily navigate between the position where the event was fired and where it was received.

Dynamic beans (CDI extensions)

In IntelliJ IDEA 2017.3, you can quickly navigate between the Injection point and Injected Beans using the icons in the gutter.

Navigation from disposer methods to their producers

You can navigate from disposer methods to their producers using an icon in the gutter.

HTTP/2 support for Servlet 4.0

One of the major features in Java EE 8 is HTTP/2 support for Servlet 4.0. HTTP/2 has an important new feature: Server push. It enables the server to send content to the client without an initial request from the client side. The main goal of this new approach is to improve the performance of web browsing. IntelliJ IDEA 2017.3 supports this new Server Push feature and offers path completion for the PushBuilder.


Neighborhood Mode in dependency diagrams.

The Spring Beans Dependencies diagram has been extended with a new Neighborhood Mode feature, which lets you choose only the necessary beans and view only their dependencies.

For better readability, you can easily switch to Borderless View.

Facetless auto-configuration

IntelliJ IDEA 2017.3 automatically detects a facet for Spring projects; for Spring MVC projects the IDE now detects both: the facet and the context.

Spring Boot

Auto-detection of MVC context

The long-awaited support for Spring Boot MVC web applications is already available in the IDE. With IntelliJ IDEA 2017.3, MVC context for Spring Boot MVC web applications is automatically detected. The IDE will automatically set up a Web Facet and a Spring Boot MVC Context.

Support for Spring Boot MVC web applications

IntelliJ IDEA 2017.3 makes all of its major features available when working with Spring Boot MVC web applications, including auto-completion, syntax highlighting, and navigation to related views.

Spring Boot 2.0 Actuator Endpoints

IntelliJ IDEA 2017.3 supports Spring Boot 2.0 Actuator Endpoints.

Highlighting for Spring Boot configuration files

In Spring Boot configuration files, the values are now highlighted according to their type.

Project configuration

Unloaded modules

When you update a project that has unloaded modules via a VCS, the IDE will analyze all the dependencies between the modules. If the newly added modules depend on existing ones, they will be marked as loaded; otherwise, as unloaded.

The IDE also checks whether unloaded modules compile successfully before a commit.

learn more


Coverage for Gradle

IntelliJ IDEA 2017.3 lets you run tests with coverage by using the Gradle Test Runner. You can even run tests with coverage if you select the Delegate IDE build/run action to Gradle option. Choose how you want to run your test with coverage from the main editor: with the platform test runner or with the Gradle Test Runner.

Build tool window

IntelliJ IDEA 2017.3 introduces a new Build tool window for Gradle build output. Previously, in some cases, Gradle build output was hidden in a background process, now it is displayed in the Build tool window. The output from the running task and test is shown in the Run and Debug window, as it was in IntelliJ IDEA 2017.2.

Editor-based REST client

Brand new editor-based REST client

IntelliJ IDEA 2017.3 introduces a brand new editor-based REST client. To start using the new REST client, create a scratch file with the .http extension. Use the icon on the left-hand panel of the editor to run a request. For easier navigation, the IDE will add a link to the request results.

Environment variables

In the new editor-based REST client, you can define the context for executing a request. Create a rest-client.env.json file inside your project and define an environment with variables. Once the environment variables are defined, you can easily switch between different environments such as production, testing, and development.


The Kotlin plugin bundled with the IDE has been updated to Kotlin 1.2. Now support for the experimental Kotlin multiplatform projects is available inside the IDE. This new Kotlin feature makes it possible to reuse code between target platforms supported by Kotlin, which are JVM, JavaScript, and (in the future) Kotlin/Native. Learn more.

Detecting expected declarations without the actual implementation

To call platform-specific code from a common module, you can specify expected declarations – declarations for which all platform-specific modules need to provide actual implementations.

Expected declarations should have actual implementation in the platform-specific module. If you try to use an expected declaration without the actual implementation, IntelliJ IDEA 2017.3 will detect the problem and alert you.

Intention action to create the actual class

The Kotlin plugin provides an intention action to create an actual implementation for missing declaration for JS and JVM platforms.

Navigation from expected declarations to actual implementations

For the multiplatform project feature, the IDE provides a gutter icon to let you easily navigate between expected declarations and actual implementations.

Version control

Interactively Rebase from Here in Log

Git integration in IntelliJ IDEA allows you to edit your project history by performing Interactive rebase before you apply changes from one branch to another. To make it even easier to use, starting with IntelliJ IDEA 2017.3 you can invoke it right from the Log tab of the Version Control tool window. To edit several commits in the current branch, select the oldest commit in the series and choose the Interactively Rebase from Here action from the context menu.

Preserving workspace when switching between branches

In IntelliJ IDEA 2017.3, Git integration supports working with multiple branches. When you switch between branches, the IDE preserves your workspace: the opened files, the current run configuration, and the breakpoints. The workspace associated with a branch will be automatically restored when you switch back to that branch.

Improvements for Git and Mercurial merge commits

Starting with this update, the IDE shows files changed by merge commits, even if they only differ from one parent. Previously only the files that had merge conflicts were displayed.

Furthermore, the IDE now displays a 3-panel Diff for merge conflicts.

Suggesting author and commit details for changes from patches

IntelliJ IDEA 2017.3 now reads the author and commit details provided by git format patches, so you don’t need to enter them manually when committing patches from the IDE.

Rename shelved changes

Changelists can now be renamed on the Shelf tab. Drag a changelist from the Local Changes tab to the Shelf tab, freeze for a second, and the Shelf tab will be activated allowing you to specify a new name for the shelved changelist.

Unshelve changes with drag’n’drop

Drag-and-drop a changelist from the Shelf tab to the Local Changes tab, and select a changelist to put it into.

Database tools

Grouping Data Sources

IntelliJ IDEA 20173.3 includes a new database tools feature: the ability to group data sources. Press F6 or choose Move to group… from the context menu.

Foreign Data Wrappers in PostgreSQL

Foreign Data Wrappers, and as a consequence, foreign tables, are now displayed in PostgreSQL.

Select schema & data source on running a file

IntelliJ IDEA 2017.3 now prompts you to choose a database/schema along with a datasource when you try to run an SQL file from the Project tool window.

Jump to Console from Data Source

For easier navigation, we’ve upgraded the context menu for datasources in the Database tool. Choose Jump to Console, and you’ll now have a handy menu for quickly switching between your consoles.

XQuery and XPath coding assistance

The XQuery/XPath support for Microsoft SQL Server is now provided through the Injected Languages feature.

Right-side alignment for numeric data

For better readability, the IDE now right-aligns numerical columns data in the data editor.

Synchronize IDE settings across devices

IntelliJ IDEA 2017.3 ensures better synchronization of your settings across different installations. It provides a more convenient method for storing your settings, utilizing a JetBrains repository to store items such as the UI theme, colors, fonts settings, and so on. You can apply these settings to all of your IDE instances using your JetBrains Account (JBA).

You can also synchronize the list of installed, enabled, and disabled plugins.

learn more


Highlighting of implicit usages

The Scala plugin now detects and highlights usages of a symbol in the current file even when it is used implicitly.

Build, Run, and Test processes do not depend on indexing anymore

For Scala integration, building or test execution processes shouldn’t require indexing, but this was not completely true until now. Previously, a number of dependencies forced you to wait until the IDE finished indexing. With this release, we’ve completely changed the logic, so you now you can run your existing run_configurations (application, tests …) in parallel with indexing. It’s especially useful for big projects where indexing takes considerable time.

Automatic SBT library import

Now the IDE suggests importing SBT libraries from the local Ivy cache.

Ammonite scripts support

The Scala plugin 2017.3 also provides support for Ammonite scripts. We’ve added:

  • Proper highlighting and navigation that respects the ammonite syntax
  • Run configuration with a gutter icon for launching scripts
  • Ammonite annotations
  • An action to import of {code}$ivy.{code} dependencies. This may be required for accurate resolution in the Editor.

A new wizard for Lightbend Tech Hub templates

As you may already know, Lightbend Activator was EOL-ed on May 24, 2017. It was replaced with the new technology: a "project starter" service. Following these changes, the Scala plugin has introduced a new Lightbend Project Starter wizard.


New UI for Run/Debug Configurations dialog

The Docker Run/Debug Configurations has been split into 3 different types: Docker Image, Dockerfile, and Docker-compose. The dialogs for these three types have been totally redesigned.

For Docker Image and Dockerfile run configurations in the Create Docker Configuration dialog, it’s now possible to accept the CLI arguments directly, without converting the docker run command into a JSON file.

With the Docker plugin, in addition to using environment variables for Dockerfile and Docker Image, you can also set files with environment variables in the container during a docker build.

Build Image action

A new Build Image action was added to the gutter for Dockerfile.

Custom names for Dockerfile and docker-compose files

The Docker plugin now supports Dockerfiles and docker-compose files with custom names and paths.

User Interface

Multiple soft limits

IntelliJ IDEA now allows you to сonfigure several visual guides to help control code width. The possibility to add multiple soft limits is now available in Settings/Preferences | Editor | Code Style.

Preview for SVG files

IntelliJ IDEA 2017.3 introduces a new Preview panel for the SVG editor. Observe the changes in the Preview panel while editing an SVG file in the editor.

2017.2 Jul 18


Smart completion

Chain Completion, which was available on the second call of Smart Completion, gets even better. Now the suggestions are displayed after the first call of Smart Completion, and they’re sorted by how frequently they’re used in the project. This feature works only for Java and requires the project to be built with the IDE’s (not Gradle’s) compiler.

Smart Completion is now aware of builder classes in the project and suggests their usage where relevant.

Control flow analysis

Control flow analysis has become much smarter and now detects a wider variety of problems in the code.

For example, if Collection#isEmpty() returns true, the IDE understands that there are no elements in that collection to iterate over.

The IDE also understands that String#charAt(int index) throws an exception when called with an empty string, or when the index exceeds the value returned by the String#length() method.

The same intelligence applies to: String#isEmpty(), String#charAt(int index), List#get(int index), Set#contains(Object item), Map#containsKey(Object key), Map#containsValue(Object value), and many other methods.

The IDE also gains a better understanding of reporting nullability issues, in particular when it comes to working with Collection and Map type parameters.

Java 9 module diagrams

Embracing Java 9 and its new module system, the preview introduces Module Diagrams. Use them to see the dependencies between the selected modules. To see the diagram, invoke Diagrams | Show Diagram (Ctrl+Alt+Shift+U), and then choose Java Modules Diagram.

The diagram works for JRE modules as well.

Refactoring to Java 9

The IDE finds the code where you construct sets and pre-fill them with data, and suggests replacing it with Set#of(String…items) where possible.

The IDE finds the loops spinning on a volatile field and suggests calling Thread#onSpinWait() inside such a loop. This call may significantly improve the performance of your code.

Extracting an expression as a map operation

Now, when you call Extract Variable inside a Stream API map call, the IDE offers to extract it as a separate map() expression.

Extracting a functional variable

Embracing Java 8 in one of the earlier releases, we introduced Extract Functional Parameter. With this preview, we’re going further and introducing Extract Functional Variable.

Extracting a lambda to a method reference

IntelliJ IDEA now offers you a quick-fix that replaces a lambda expression with a method reference. This combines Extract Method and Replace Lambda with Method Reference.

Replacing multiple equals with Set.contains

When you are checking whether an expression is equal to one of several literals, the IDE now offers you to replace these checks with a Set#contains(Object key) call.

JUnit 5 M4: parameterized and repeated tests

Following the recent JUnit 5 changes, the IDE adds dedicated coding assistance for Parameterized Tests and Repeated Tests.

Reflection API

Coding assistance for Reflection has gotten better. Also, we’ve introduced similar coding assistance for Method Handlers and Variable Handlers.

IntelliJ IDEA provides code completion for method and field names as well as their signatures.

JVM debugger

Filtering arrays & collections

The debugger now allows you to filter arrays and collections in Variables, Watches, Evaluate Expression and other similar views.

Java Stream Debugger

Out of the release scope, but you may also find it interesting to know that recently we introduced a new plugin called Java Stream Debugger. This plugin provides visualization of Java Stream operations.

You can use the plugin if you’re running IntelliJ IDEA 2017.1 or newer.

Spring Boot

Run Dashboard

For Spring Boot applications, the traditional Run tool window has been replaced with Run Dashboard. This dashboard lets you manage Run configurations and see their application-specific information on the right.

Actuator endpoints

For Spring Boot applications, the Run/Debug tool window now has a tab called Endpoints. This tab shows information about the Health, Beans, and Mappings endpoints.


Progress indicator

When Gradle is downloading a wrapper distributive, the IDE now displays the progress bar in both the Console tool window and the Background Tasks popup.

Environment variables

When you run a Gradle task via a Run Configuration, you can now specify and/or override environment variables.

On macOS, the Gradle build is now consistent with the command line behavior because the IDE now respects environment variables defined on the system level.

Kotlin 1.1.3

Semantic highlighting

Now, if you enable Semantic highlighting in the Colors & Fonts settings, the IDE highlights the definitions and all occurrences of local variable, and parameter with a distinct color.

TODO highlighting

The usages of the TODO() method are now highlighted in the editor as TODOs and shown in the TODO tool window.

Parameter names

To make the code even more readable, the editor now shows hints for the parameter names in method calls where the meaning of the arguments may not be clear from the context.

Type hints

Similarly to Parameter Hints, the editor now is capable of showing inferred types for the variables, functions, and parameters. This functionality is disabled by default; you can enable it in the editor appearance settings.

Groovy 2.5.0

The update brings the support for the new features introduced with Groovy 2.5.0: @groovy.transform.builder.Builder#includeSuperProperties, @groovy.transform.AutoImplement, and @groovy.lang.Delegate for methods


Debugging in SBT Shell

Earlier this year we introduced SBT Shell to make the work with SBT projects more convenient. Now, you can easily attach a Debugger to it with just one click.

Play 2.6 support

The support for Play Framework has been updated according to its latest version.

Implicits management

The Type Annotations inspection has been improved with implicit declarations processing. Any implicit is worth being explicitly annotated. It significantly increases the performance of compilation and IDE code analysis. It reduces the risk of a type inconsistency.

Completion for implicits

Now, if you call Smart Completion for following types: akka.actor.ActorRef, scala.concurrent.Future, it also suggests implicit conversions, and adds import statements automatically.

Version control

Reverting and rewording commits

The Git Log now provides two new actions: Revert and Reword. The first one lets you revert selected commits.

The second one lets you change the commit message for any commits that have not been pushed yet.

Formatting commit messages

The settings related to the Commit dialog have been reworked and moved to a separate page called Commit Dialog.

The new settings let you customize the rules applied to commit messages: a blank line between the subject and the body, and the maximum length. Also, now the IDE offers a quick fix and the Reformat action inside Commit Message.


The Shelf tab has been reworked for better performance and ergonomics.

The Show Diff action now by default compares the shelved version to the base version instead of local (when possible). The old behaviour, which is comparing to the local version, is available via the Compare with Local action (listed in the context menu).

The raw patch content can be viewed in the Preview tab.

User interface

Find in Path

The Preview panel in Find in Path now has a Gutter (a left-hand pane like that in the editor) with line numbers, navigation icons, and local change markers.

Search results from the same lines are now merged together.

A small icon indicates when a search is in progress.

Window 10 native UI

The appearance of certain UI elements on Windows 10 has been updated to follow the system look and feel. This includes buttons, radio buttons, checkboxes, text fields, select controls, spinner and a few others.

Better HiDPI support

The IDE used to scale its UI based on the global settings of the primary display. This scale factor was applied even to non-primary monitors. Now it scales its UI based on the scale factor for the monitor the UI is shown on. This improvement has a limitation: it works only for Windows and doesn’t support fractional values.

The font settings are now automatically adjusted based on the display resolution.

JavaScript & TypeScript

Parameter hints and type info

Parameter hints make the code easier to read by showing parameter names in method and function calls. Now, you can also now see the inferred type for objects by hovering over them with the mouse and holding Ctrl.

Code arrangement

The new Arrangement code style options allow you to configure how different blocks of code such as the constructor, fields and methods are ordered in your JavaScript and TypeScript classes. Call the Rearrange Code action or use it together with Reformat Code to make the code more readable and consistent.

Import code style from .eslintrc

You can now import some of the ESLint code style rules to the IDE’s JavaScript code style settings. Reply Yes when prompted about this in the .eslintrc file – that will apply the matched rules and make the IDE formatting more consistent with your ESLint configuration.

Move symbol refactoring

With the new Move Symbol refactoring you can now safely move classes, global functions or variables across ES6 modules – all the imports and exports will be updated automatically.

CSS modules

Using CSS Modules? Now when you’ve imported a CSS Module in your JavaScript file, you will get code completion and navigation to the definition for the class names in that module.

Angular Material

Support for Angular Material improvement: you can now use code completion and navigation for the Material attributes in addition to completion, for the components that were available before.


Coding assistance in JavaScript files now respects the webpack module resolution. Now when you’re using a complex webpack configuration with aliases and multiple modules, the IDE properly resolves the paths in import statements and suggest symbols to import.

Code coverage for Mocha

Run Mocha tests with coverage and see the coverage reports created by Istanbul right in the IDE. The report shows how many files were covered with tests and the percentage of covered lines in them. From it, you can jump to the file and see what lines were and were not covered.


Unloading modules

The preview brings a new experimental feature called Unloaded Modules. This feature gives you the ability to select which modules you are going to work on in your project. Those you are not working with at the moment are marked as Unloaded. The IDE will not index or otherwise touch any files in Unloaded Modules. This helps conserve CPU and memory resources when dealing with large codebases.

To access the feature, invoke the Project tree context menu and select Load/Unload Modules.

Then, if you’re are looking for usages of a symbol, or are about to refactor something, the IDE will warn that there are unloaded modules that depend on the modules you are working with, and therefore might contain code that should have been affected by the action, but won’t be.

Excluding files by pattern

To remove irrelevant files from search results and also improve indexing performance, now it's possible to specify a set of filename patterns to be excluded from indexing.

Pausing indexing

The indexing process now can be paused, e.g. if you need your CPU power for an urgent task.

your edition


For web and enterprise development


For JVM and Android development
License Commercial Open-source, Apache 2.0?
Java, Kotlin, Groovy, Scala
Android ?
Maven, Gradle, SBT
Git, SVN, Mercurial, CVS
Detecting Duplicates ?
Perforce, TFS
JavaScript, TypeScript ?
Java EE, Spring, GWT, Vaadin, Play, Grails, Other Frameworks ?
Database Tools, SQL