Replacing streams with loops

Replace complicated chains of stream API calls with for loops for better readability or debugging of complicated chains.

Regexp syntax highlighting

Dedicated section in Settings → Editor → Colors & Fonts for RegExp syntax highlighting.

Overriding methods

You can now choose which annotations will be copied to the overriding implementation from its super method.

Faster method breakpoints

Method breakpoints have been optimized and now their use does not cause significant performance penalties.

Emoji

Code editor fully supports Unicode emoji characters, rendering them as colored images on On Mac OS X, and monochrome images on other systems. You can use emoji in comments, String literals, and resources.

Zero-latency typing

Zero-latency typing, a feature that combats typing lags, is not experimental any more and is enabled by default.

Search options

Log viewer now supports regex and case-sensitive commit message search.

Logback files

Coding assistance is provided for editing appender configuration: code completion, finding usages, navigation and renaming.

Application Forge

Project Wizard is now integrated with Grails Application Forge, an utility that simplifies creating of Grails applications.

Class-level watches

Now you can define watch expressions on the class level. These watches appear as extra fields of the class but are evaluated based on your expressions. An expression for class-level watches is defined in the context of the class.

Memory view

With the help of the new JVM Debugger Memory View plugin you can explore objects in the JVM heap during a debug session.

When you’re stepping over the code, the Diff column shows you how the number of objects changes between debugger stops. A double click on a class name, opens a dialog with instances of the class. If needed, the plugin is also capable of tracking stacktraces for chosen classes.

Log for Git & Mercurial

• Search speed has improved dramatically, particularly for the Text, Author and Path filters.
• Commit details have moved to the right, giving more space to the Log itself.
• Commit messages in the table are now aligned and thus more readable.
• Labels have been moved to the right side and are now displayed in a more elegant way.

Syntax highlighting in the Diff and Merge dialogs

We've added full syntax highlighting for non-local revisions in the Diff and Merge dialogs.

To get it working, we’re building the PSI tree rather than relying on lexer tokens. As a nice side effect you get code navigation here as well.

Undo commit

Now you can undo your last change (that you haven't yet pushed) in one click via the Log's context menu.

Sign-off commit

The Commit Changes dialog allows you to sign-off your commit. This may be a requirement for getting patches into some projects (including the Linux kernel).

Parameter hints

The editor now shows parameter hints for literals and nulls used as method arguments. These hints make code much more readable.

If you find hints redundant for a certain method, you can tell the IDE not to show hints for this method. To disable hints completely, uncheck Settings → Editor → General → Appearance → Show parameter name hints.

Flat file icons

In this update we've reworked the file icons to achieve a flatter design. While the new icons may look unusual, hopefully they feel sharper and less noisy to you.

Later, we may introduce flat icons to other parts of the IDE as well.

Resource bundle editor

The Resource Bundle editor now shows you which properties are unused in the project.

Fira Code font

Another font-related change, now affecting all platforms, is Fira Code which is now bundled with the IDE and allows everyone to use Font Ligatures.

Refactoring to Java 8

Now, if you press Alt+Enter inside a non-trivial for-loop, the IDE will prompt you to replace it with a chain of stream API calls. It supports count, flatMap, map, mapToInt, collect, filter, anyMatch, and other Stream methods. learn more

Also, when appropriate, the IDE will prompt you to replace certain code with Map.computeIfAbsent, Collections.removeIf or ThreadLocal.withInitial. learn more

Inlining local variables used only by return statements

The new inspection finds local variables used only by return statements, and provides a quick fix that inlines these variables–by replacing their assignments with return statements.

When the returned value can’t be inlined into a return statement, the quick fix attempts to move the return statement as close to the computation of the returned value as possible.

Some intentions became quick-fixes

Unlike intention actions, inspection quick-fixes can be applied to many files at once. We've chosen several intentions that may work better as quick-fixes and converted them: Lambda can be replaced with anonymous class and Diamond can be replaced with explicit type arguments to name a few.

Unused declaration options

Now you can manage the Unused declaration inspection by choosing which members to report.

Loop to Lambda Conversion

The Kotlin plugin can now detect many non-trivial cases where imperative for loops can be rewritten in a more compact and idiomatic manner using standard library functions such as filter, map, flatMap, count, etc. To trigger the conversion, put the caret on the for keyword and press Alt+Enter.

Postfix Completion

IntelliJ IDEA’s postfix code completion is now supported for Kotlin, with a large array of templates.

Scala.js

We’ve added better support for js.Dynamic. The Scala plugin now provides code completion and quick navigation to fields and methods defined in JavaScript libraries or project files.

Akka

The plugin now suggests actor constructor parameters in Akka’s Prop method (Ultimate only).

Delegate IDE build/run actions

We’ve added an option that delegates the native IntelliJ IDEA actions Build, Build Artifacts (both WAR and EAR) and Run to Gradle. Select Settings → Build, Execution, Deployment → Build Tools → Gradle → Runner → Delegate IDE build/run actions to gradle.

When this option is enabled, all these actions are performed via corresponding Gradle tasks.

Meta annotations

We've added support for meta annotations based on @Autowired and @RequestMapping (including user-based and built-in annotations such as @GetMapping and @PostMapping).

In Spring Boot projects the Console now doesn’t require persistence.xml in the JPA facet. Also, the IDE now respects the naming strategies provided with Spring configuration files.

Liberty

Loose applications now can be run from the IDE. To run a loose application, open the Deployment tab of your WebSphere Run configuration and select the loose application XML file, instead of an artifact.

Convert var to const/let

Now, the IDE reports all var declarations and help replace them with let or const declarations, depending on value semantics.

Convert to class

The IDE can now convert complicated prototype chains into a hierarchy of classes.

Rename refactoring

When you rename a method that overrides or implements another method, the IDE now offers to rename the base method too.

If you choose to rename the current method only, the IDE makes sure to rename all methods that override the current one.

Templates coding assistance

Coding assistance within templates is now more precise and aware of available types.

Protractor

Integration with Protractor, an end-to-end testing framework for Angular apps, now lets you easily run and debug tests in the IDE and see test results in a tool window, with options to filter them and quickly jump to the test source.

Debugger

Now you can run and debug React Native apps without leaving IntelliJ IDEA.

All it takes is a new React Native Run/Debug configuration. Just create one, select the target platform, and make sure that the path to the React Native CLI package is correct.

PostCSS

IntelliJ IDEA now offers a plugin for PostCSS. The plugin provides code completion, formatting, navigation, inspections, rename refactoring, and more.

Blueprint mode

The new Blueprint mode in the Designer hides all of the visuals from views and shows only their outlines. You can choose to have it side by side with the Designer.

APK analyzer

The new APK Analyzer lets you drill into your APK to help you reduce your APK size, debug 64K method limit issues, view contents of Dex files and more.

Editing multiple cells

Now you can edit several similar cells at once. Select several cells and start typing a value. If you need a cell editor (e.g. a Data Chooser), click Enter.

Finding usages

Now you can find usages of objects inside the source code of other objects. For instance, you can learn in which stored procedures, functions or views your table is used. As usual, press Alt+F7 on the table name or call it from the context menu.

Local changes

Now when you edit the source code of any object, the IDE tracks your changes and highlights edited rows in the left editor panel. If you click on a highlighted row, a small toolbar is displayed with a Show Diff link.

Coding assistance

Now if you use JOIN USING for Postgres, the IDE offers you only the field names common for both tables.

The INSERT statement completion offers you not only the list of all fields but also the list of fields which have no default value.

If a variable or parameter is not used within its scope, you'll get a warning.

You'll also get a warning if there is a mismatching number of columns in queries used in set operators (UNION, INTERSECT and EXCEPT).

Introspect schema/database

Now, when you access a schema or database not introspected by the IDE yet, it will provide a quick-fix for that.

Google Cloud Tools

Google has introduced their own IDE plugin for deploying to Google App Engine. Eventually this plugin will replace the Google App Engine plugin provided by JetBrains.

Watches and variables

The Watches view has been merged with Variables for more convenience.

Log

The Log viewer for Git and Mercurial continues getting better:

• It loads in the background on every change (a commit, fetch, rebase, etc). As a result, it’s always ready when you open it.
• We’ve reworked the way the Log shows the loading progress. Now, when refreshing, there’s a thin stripe shown under the toolbar.
• When you select several commits, you see all commit details.
• Ctrl+L can be used for navigating to the Filter field.

Case-only renames

We've added support for case-only renames in Git for Windows and macOS.

JUnit 5

The IDE update brings support for JUnit 5, the next generation of the most popular unit testing framework for Java.

Ligatures

We've added support for monospace font ligatures. To enable ligatures, go to Settings → Editor → Colors & Fonts → Font, choose a font that supports ligatures, e.g. FiraCode, Hasklig, Monoid or PragmataPro and select Enable font ligatures option.

Inspections tool window

The Inspection tool window has been redesigned for better ergonomics: now the code location for each problem is displayed, along with controls to apply a quick-fix or suppress the inspection.

Spring Core 4.3

• A quick-fix suggesting to replace field injection with a constructor injection.
• Generic types as qualifiers.
• EventListener meta annotations defined with @AliasFor.
• Highlighting and navigation for Spring messages in Console.
• Better performance.

Spring MVC

Code completion and navigation within FreeMarker or Velocity templates for defined variables.

ECMAScript 6

The IDE now helps convert callback functions to arrow functions when you click Alt+Enter on the function keyword. Also, it can convert arrow functions to shorthand arrow functions.

React

The IDE can now understand component properties defined via propTypes and provides code completion for them.

The component lifecycle methods (e.g. componentDidMount, etc) aren't shown as unused anymore.

Another nice improvement is that now IntelliJ IDEA will automatically add {} instead of “” for React events like onClick, onChange, etc. Moreover, the IDE now understands React non-DOM attributes: key, ref and dangerouslySetInnerHTML.

Npm, Grunt and Gulp

Now you can specify any Grunt, gulp or npm task as a Before launch task in a Run/Debug configuration.

• Code completion for database names in Data Sources and Drivers.
• Auto-scroll from Editor option in the Database tool window.
• Code completion is more relevant now: it doesn't suggest functions when a table name is expected.

The update includes the Android Studio 2.0 features: faster Emulator, experiment GPU Debugger, faster full builds, and code generation and testing for App Indexing. Note, Instant Run is not fully-merged yet.

Groovy expressions

Now when debugging a Java application, you can use Groovy expressions with Evaluate Expression and Watches. Previously you could do that only when debugging Groovy code. This is good because Groovy expressions are much shorter and more expressive (especially when you work with collections).

Sources mismatch detection

It might be very annoying and counterproductive if you're stepping over your code unaware that it does't actually match the running code. To avoid any unnecessary time waste, the IDE now immediately warns you once it sees a mismatch.

Two new actions are available via the Branches popup: Checkout with Rebase and Rename.

The Checkout Tag or Revision action is now applied to all repositories configured for the project.

If you do an Interactive Rebase, IntelliJ IDEA now automatically stashes and unstashes local changes and assists with resolving conflicts.

By-word changes highlighting

Merging and comparing revisions with Git and other VCS just got easier with the added by-word difference highlighting.

Now you can also disable inspections in the Diff Viewer to minimize distraction.

Move element right and left

Sometimes it might be useful to move statements to the left or right, for example when you're reordering the attributes of an XML element, method parameters, or elements in an array initializer.

To help you do it quicker, we’ve added two new actions: Alt + Ctrl + Shift + Left or Right, respectively (Alt + Cmd + Shift + Left/Right for macOS).

Right-to-left languages

IntelliJ IDEA adds support for right-to-left languages (Arabic, Hebrew) to the editor.

Method references and lambda expressions

The Inline and Change signature refactorings have been updated to correctly process method references.

The IDE will warn you if you call a method of a functional interface which is directly invoked on the definition of a lambda, method reference or anonymous class. The inspection provides a quick-fix to replace it with the body of the functional interface implementation.

Also, the IDE will report method references which point to a method of their own functional interface type and hence can be replaced with their qualifiers.

Overloaded methods or constructors with similar functional interface type parameters, for which any call sites will need a cast or parameter type specified on the lambda expression to resolve ambiguity, may now be reported as well.

Migrating Guava code to Java 8

For those who would like to migrate their Guava code to Java 8 APIs, we’ve added a number of quick-fixes that help to replace FluentIterable, Function, Optional, and Predicate with Java 8 analogues.

Declaration access can be weaker

The new inspection called Declaration access can be weaker prevents making fields, methods and classes public unnecessarily. Enable it on the scopes you need.

Show usages

We have improved the speed-search in the Show usages popup. Now, when you use it, the matches are highlighted for easier navigation.

Custom source sets

The IntelliJ IDEA project model is finally aligned with that of Gradle and supports custom source sets, by resolving dependencies between individual source sets. This improvement fixes a great number of issues.

Spring Boot

The IDE now helps you find usages of your custom configuration properties in your application configuration files and additional metadata files.

Enjoy coding assistance in YAML configuration and banner.txt files.

@SpringApplicationConfiguration is respected in test context setups.

• The aliases defined with @AliasFor for @Bean, @Import and @ContextConfiguration are fully supported.
• Added support for @EnableBatchProcessing, @EnableLoadTimeWeaving and @EnableSpringDataWebSupport annotation.
• Non-annotated beans that extend CrudRepository now are resolved correctly.

The built-in coding assistance has been updated to support Thymeleaf 3, the new version of the popular template engine.

Many issues related to Thymeleaf 2 have been also fixed.

Code completion for Scala has been significantly improved. For case classes in pattern matching the IDE now suggests parameter names based on the corresponding field names and their types.

ECMAScript 6 and TypeScript

The new refactorings include Create method, Extract method, Inline method and Introduce field.

The new intentions include Make class abstract, Make public/private and Remove modifier.

Any unused import statement is now highlighted. To remove all unused statements, call Optimize imports. Required import statements are added as you type.

Support for TypeScript has been updated to v1.8.

Debugger

The JavaScript debugger for Chrome now makes lots of new things possible. Debug asynchronous client-side code and arrow functions in ECMAScript 6, and stop on the breakpoints set in Web workers.

Also, the IDE now allows you to debug an app’s main process in a built or packaged Electron application, by using Node.js run/debug configuration. You can also debug render process by using Chromium remote debug configuration.

PostgreSQL

IntelliJ IDEA provides coding assistance the features added in PostgreSQL 9.5.

We've also added support for the PostgreSQL hstore ‘?’ operator.

SQL Server

Custom types in SQL Server (alias types and table types) are now introspected and available for completion.