# Scala implicits

> **TL;DR**
> Required plugin: Scala: [how to install](get-started-with-scala.html#scala_plugin)

## Implicit conversions

IntelliJ IDEA lets you invoke implicit conversion methods and arguments.

### List implicit conversions

Select an expression and press `Ctrl+Shift+Q` (`Ctrl+Q` for macOS) to invoke the list of applicable implicit conversions. The list shows the regular scope displayed on the top and the expanded scope displayed on the bottom of the list.

> **Note:**
> IntelliJ IDEA highlights an implicit conversion used for the selected expression. If IntelliJ IDEA cannot find the implicit conversion or if it finds more than one match, the list of Introduce Variable opens.

[Video](https://resources.jetbrains.com/help/img/idea/2026.2/choose_implicit_conv.mp4)

If you need, make the implicit conversion method explicit. Press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `Alt+Enter` (NetBeans), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)) and select Make explicit or Make explicit (Import method).

![Make explicit](https://resources.jetbrains.com/help/img/idea/2026.2/choose_implicit_with_make_exp.png)

* If you select Make explicit, IntelliJ IDEA returns a method call with the class name. It might be helpful if you need to make sure that the compiler imports a particular implicit conversion method that you originally wanted: ![Make explicit result](https://resources.jetbrains.com/help/img/idea/2026.2/make_explicit.png)

* If you select Make explicit (Import method), the method is imported statically, and IntelliJ IDEA returns just its call without the class name. Also, the next time you open the list of useful implicit conversions, you will see this method in the regular scope: ![Make explicit import method](https://resources.jetbrains.com/help/img/idea/2026.2/make_explicit_import_met.png)

### List implicit arguments

Place the caret at the method where implicit conversion was used and press `Ctrl+Shift+P` (Windows), `⌃ ⇧ P` (macOS), `⌃ ⇧ P` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ P` (macOS System Shortcuts), `Ctrl+Shift+P` (XWin), `Ctrl+Shift+P` (GNOME), `Ctrl+Shift+P` (KDE), `Ctrl+Shift+P` (Emacs), `Ctrl+Shift+P` (Sublime Text), `⌃ ⇧ P` (Sublime Text (macOS)), `Ctrl+Shift+P` (NetBeans), `Ctrl+Shift+P` (Visual Studio), `Ctrl+Shift+P` (Visual Studio (macOS)), `Ctrl+Shift+P` (Eclipse), `Ctrl+Shift+P` (Eclipse (macOS)) to invoke implicit arguments. It might be helpful for code analyzing when you want to find out what implicit arguments were passed to the particular call. It also lets you view the recursive implicit arguments.

![Implicit arguments](https://resources.jetbrains.com/help/img/idea/2026.2/implicit_arguments.png)

> **Note:**
> IntelliJ IDEA highlights the method call where implicit arguments were used.

If IntelliJ IDEA cannot find method calls where implicit parameters were passed, it displays a pop-up message:

![No implicit arguments popup](https://resources.jetbrains.com/help/img/idea/2026.2/no_implicit_param.png)

## Find Usages for implicits

You can navigate from implicits definitions to their usages using the Find Usages action. In the editor, select the implicits definition and from the context menu, select Find Usages `Alt+F7` (Windows), `⌥ F7` (macOS), `⌥ F7` (IntelliJ IDEA Classic (macOS)), `⌃ U` (macOS System Shortcuts), `Alt+F7` (XWin), `Alt+Shift+7` (GNOME), `Alt+Shift+7` (KDE), `Alt+F7` (Emacs), `Alt+F7` (Sublime Text), `⌥ F7` (Sublime Text (macOS)), `Alt+F7` (NetBeans), `Shift+F12` (Visual Studio), `⇧ F12` (Visual Studio (macOS)), `Ctrl+G` (Eclipse), `⌘ ⇧ G` (Eclipse (macOS)).

This capability relies on bytecode indexes, and can also be used to locate the following hidden elements that are not present in the source code as is:

* `apply` / `unapply` method calls

* Single Abstract Method (SAM) type instantiations

* `foreach` / `map`/ `flatMap` / `filter` / `withFilter` calls via a for-comprehension

![Find usages for implicits](https://resources.jetbrains.com/help/img/idea/2026.2/implicit_find_usages.png)

## Auto-import for implicits

IntelliJ IDEA supports the auto-import for unresolved implicit conversions. Enter your code in the editor. Place the caret at the unresolved expression and press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `Alt+Enter` (NetBeans), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)) and, from the list of the suggested options, select the conversion to import. As a result, IntelliJ IDEA adds the necessary import statements.

[Video](https://resources.jetbrains.com/help/img/idea/2026.2/result_of_implicit_auto_import.mp4)

> **Note:**
> When you place the caret at the unresolved expression, IntelliJ IDEA displays a popup suggesting the importing option. You can disable the popup notification in the [Auto Import](settings-auto-import.html) settings.