What's New in IntelliJ IDEA

2016.3 EAP

IntelliJ IDEA 2016.3 Early Access Program

The update planned for this Autumn is now available for a preview. Give it a try and share your feedback.

Give it a try

Debugger

Class-level watches

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

Primitive type renderers

Now you can define custom Java Type Renderers for primitive types too, including arrays.

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 this class.

Catch class filter

Now you can limit the scope for any Exception Breakpoint to a specific set of classes or packages where the exception is caught (via try-catch blocks).

Version control

Undo commit

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

Restore and Delete tracked branch actions

Now, when you delete a local branch, you get a notification that lets you quickly undo it or delete the tracked remote branch too.

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

Scope highlighting

Now every file shown in VCS dialogs and tool windows is highlighted with the color associated with the scope of the file.

User interface

Recent tests

Now you can press Shift+Ctrl+; and get a popup with recent tests. The popup shows successful test configurations and failed individual tests. Press Enter to re-run the selected test or F4 to navigate to its declaration.

Find in path settings

The Find in Path dialog used to reset some of its settings if you called it from the Editor. This behaviour didn't seem convenient so we changed it. Now the dialog always preserves previous settings independently of where you call it from.

Java

Lambdas in Structure view

Now if you press Ctrl+L in the Structure view, it'll show lambda expressions.

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.

Meta-annotations hierarchy

The Type Hierarchy view now works for meta-annotations as well.

JavaScript and CSS

Flow

Now, when you set JavaScript version to Flow, the IDE reports problems in the files annotated with "// @flow" on the fly.

Make sure you've specified the path where Flow is installed in SettingsLanguages & FrameworksJavaScriptFlow.

Rename in TypeScript

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.

Angular CLI

Now you can quickly generate Angular 2 components, directives, services, and other blueprints by pressing Alt+Ins and choosing Angular CLI from the Generate popup.

PostCSS

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

Grouping generated files

For more convenience, the Project tool window now groups generated files together with the source files: e.g. ".css", ".css.map" and ".sass"; ".js", ".js.map" and ".ts"; etc.

2016.2 Jul 12

Debugger

Watches and variables

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

Multiline expressions

Multiline expressions are now supported in breakpoint’s Condition and Evaluate and log, and Data Type Renderers.

Version control

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.

Patches

A patch can be applied from the clipboard (when the IDE obtains focus), or by dragging a file into the IDE.

If a file has been moved or renamed since a patch was created for it, the IDE will try to figure that out or let you manually choose the file to apply the patch to.

In case the file has been changed since a patch was created for it, but IntelliJ IDEA cannot find its original revision, you'll be prompted to apply the patch using a Merge-like dialog.

Also, the Apply Patch dialog provides the Show Diff action to compare the patch to your local version. While comparing, you can edit your the local version.

Case-only renames

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

Unversioned files

The Commit dialog shows unversioned files so you don’t forget to commit something important.

Java

JUnit 5

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

Inspections

The IDE warns you when you instantiate new objects inside equals, hashCode, compareTo or Comparator.compare methods.

User interface

Ligatures

We've added support for monospace font ligatures. To enable ligatures, go to SettingsEditorColors & FontsFont, choose a font that supports ligatures, e.g. FiraCode, Hasklig, Monoid or PragmataPro and select Enable font ligatures option.

Breadcrumbs

Until now breadcrumbs were only available in HTML and XML code. Now breadcrumbs work for Java, too, where instead of tags they let you navigate through classes, lambda expressions and methods.

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.

Background images

Also, we’ve added a new action called Set Background Image. Give your IDE a custom look by choosing a background image for the editor and the IDE frame.

The action is available via Find Action and, for a selected image file, via the context menu for the Project tool window and Image Editor.

Notifications

We've reworked the way IntelliJ IDEA displays notifications to make them a little bit more friendly: the popups are now displayed in the right-hand bottom corner (next to the Event Log tool window icon), more compact, and grouped by the subsystem they came from.

Spring Frameworks

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 Caching

  • Support for CacheResolver, CacheManager and KeyGenerator components.
  • An inspection that ensures that a cache name is provided for cache-related operations.
  • An inspection that warns you if you use Caching annotations on interfaces.
  • An inspection that warns you if you use CachePut and Cachable with the same method.
  • Support for Cachable meta annotations defined with @AliasFor.
  • Context dependent assistance for editing SpEl in annotations.
  • A gutter icon for navigating to other operations related to the same cache name.

Spring MVC

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

Spring Security

  • Support for all major features added in Spring Security 4.0.
  • Context dependent assistance for editing SpEl in annotations and XML.

JavaScript

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.

Postfix completion

In addition to the .var postfix template, added earlier, now you can use .let and .const templates. As you might guess, when you press Tab these expand into declarations with let and const keywords.

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.

AngularJS

We’ve added a collection of Live Templates for Angular 2. To use a template, type its abbreviation in the editor and then press Tab to expand it. Press Tab again to jump to the next edit location in the template.

Also, the Project Wizard now supports Angular CLI.

Npm, Grunt and Gulp

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

HTML code style

Now you can configure whether you want the IDE to add single, double or no quotes at all when autocompleting attributes in HTML and JSX.

TypeScript

The update brings support for TypeScript 2.0 features: optional class members, readonly property, never type, this function type, global module export declaration, resolve for type declarations in @types folder, path mappings based module resolution, and more. Also, try smarter support for enums.

Database Tools

  • 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.
  • Surround With now includes function.
  • Table Editor provides completion for column values.
  • Resizing columns via Ctrl+Shift+Right/Left.
  • PostgreSQL support has been extended to Schema Search Path, Range types and types with TimeZone.
  • Learn more…

Android

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.

2016.2 Jul 12

Debugger

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

Threads

Until now, stepping over one thread meant IntelliJ IDEA would also resume all the other threads. Now you can change this behavior by enabling the Resume only the current thread option.

The debugger is now also aware that your current thread is being blocked by another suspended thread, and suggests resumeing it.

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.

Debugging without debug info

When you debug code compiled without debug info, you are provided with better name matching, and allowed to set and evaluate values for slot variables.

Version control

Git

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.

Git 2.5 introduced worktrees to simplify working with clones of a single repository: instead of making a repository clone you can create a lightweight worktree. Now IntelliJ IDEA lets you work with those worktrees just like you do with regular repositories.

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.

Compare revisions between branches

For Mercurial we've made it possible to compare revisions of a file between branches (previously possible only within a single branch).

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 OS X).

Importing static members

Previously IntelliJ IDEA provided a quick-fix to import static methods. Now it suggests adding static imports in the very same way as it does with regular ones. Static constants are suggested, too.

If you enable Add unambiguous imports on the fly, IntelliJ IDEA will import unambiguous static members on the fly.

Right-to-left languages

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

Prepend comments with a space

The code styles now provide an option to always prepend automatically added comments with a space.

Inspections

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.

Misuse of java.util.Optional

The IDE will help you avoid writing unsafe code when using java.util.Optional: it will warn you if you call get() without first calling isPresent() to check if the value is available.

Also, the IDE may warn you if you use java.util.Optional<T>, java.util.OptionalDouble, java.util.OptionalInt, java.util.OptionalLong or com.google.common.base.Optional as the type for a field or a parameter, or if you use java.util.Optional or com.google.common.base.Optional types with an array or collection type parameter. Note that this setting is disabled by default.

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.

Concurrency annotations

The built-in inspections that detect issues with use of concurrency annotations now support javax.annotation.concurrent.* (previously reported only for net.jcip.annotations.*).

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.

Ignoring duplicates in generated code

The inspection that finds duplicated code now provides an option to ignore the sources marked as generated.

Speed search

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.

Terminal

Now you can enjoy the speed search even in the Terminal tool window.

Gradle

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.

Importing EAR artifacts

IntelliJ IDEA now can resolve EAR artifacts defined in your build scripts and configures them automatically in Project Structure.

Spring Frameworks

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.

For more details, see the blog post.

Spring MVC

Finally, we’ve added support for @EnableWebMvc-based as and improved working with Java-config only setups.

Spring Core

  • 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.
  • Support for Spring 4.3: @Autowired is not required if the bean only defines one constructor.
  • The facet configuration now processes dependencies recursively.
  • A lot of auto-wiring issues have been fixed, as well as the performance has been greatly improved.

Thymeleaf

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.

With Thymeleaf users may create their own dialects or extending the standard one. IntelliJ IDEA now understands user-defined dialects and offers coding assistance for them.

Android

IntelliJ IDEA ships with the new features added in Android Studio 1.5.

  • The memory profiler can now assist you in detecting the causes of leaked activities.
  • Several new lint checks.

Kotlin

After a long and exciting road, Kotlin has finally reached the first big 1.0. Welcome the first-class programming language for JVM and Android in IntelliJ IDEA.

Scala

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.

The order of suggestions now depends on the type of symbol and its usage history. The IDE prioritizes local variables, then parameters, then fields, then methods, etc. If the IDE expects a type, it will take that also into account.

JavaScript

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.

AngularJS 2

Code insight and navigation are available for directives, variables defined in templates, custom event handlers, paths in templateUrl and styleUrls fields, and many other situations.

Enjoy coding assistance for event and property bindings, which also works inside any data binding.

Also, the IDE now understands components defined using the new AngularJS 1.5 module.component() helper method.

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.

JSON Schema

Thanks to support for JSON Schema, a format for describing JSON files, IntelliJ IDEA can now provide coding assistance for certain types of JSON files. You can add one of the schemas available in the project’s repository, or create your own schema and then map it to a specific JSON file in your project. Code completion for tsconfig.json, .eslintrc and .babelrc is now powered by JSON Schema.

Database Tools

PostgreSQL

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

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

Table and column comments

Table and column comments now can be added and modified from the Create/Modify Table dialog (if the database supports that).

SQL Server

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

Table truncation

Sometimes you may want to remove all rows from selected tables. Our new action is at your help.

Docker

The Docker plugin has been improved in many ways:

  • We’ve added support for Docker Machine
  • The IDE now offers a separate tool window for Docker.
  • The right-side panel now allows you to see logs and manage environment variables and port bindings.
  • The lists of containers and images are now separate and more readable.

Choose
your edition

Community

For JVM and Android development

Ultimate

For web and enterprise development
Java, Kotlin, Groovy, Scala
Android ?
Maven, Gradle, SBT
Git, SVN, Mercurial, CVS
Detecting Duplicates ?
Perforce, ClearCase, TFS
JavaScript, TypeScript ?
Java EE, Spring, GWT, Vaadin, Play, Grails, Other Frameworks ?
Database Tools, SQL