Java

Last modified: 01 August 2022

Settings/Preferences | Editor | Inlay Hints | Java

Parameter hints

Parameters with names that are contained in the method name

Controls whether parameter hints should appear for methods that take a single argument when the expected argument is clear from the method name, for example: void setName(String name) or void addMessage(StringBuilder message).

Non-literals in case of multiple parameters with the same type

Controls whether parameter hints should appear for methods that take more than one parameter of the same type, for example, void printSomething(String s1, String s2) when you pass non-literal values to them, for example: a.printSomething(args[0], args[1]).

Builder-like methods

Toggles the visibility of parameter hints for methods that return an instance of the enclosing class, for example:

class DuckPond{
    private DuckPond(){};
    public DuckPond newPond(){
        return new DuckPond();
    }
}

Methods with same-named numbered parameters

Toggles the visibility of parameter hints for methods that take multiple parameters, whose names consist of one letter followed by a number, for example:

public void print(String s1, String s2, String s3)

Enum constants

Toggles the visibility of parameter hints at enum constant declarations, for example: 

enum Language{
    ENGLISH("Hi"), SPANISH("Hola"), FINNISH("Hei");
    String greeting;
    Language(String greeting){
        this.greeting = greeting;
    }
}

'New' expressions

Toggles the visibility of parameter hints for parametrized constructor calls, for example: new Person("Taka", 29)

Complex expressions: binary, functional, array access and other

Controls whether parameter hints should appear where a complex expression is used as a parameter, for example, a Java 13 switch statement: 

a.printSomething(switch (i) {
    case 1:
        yield "Apples";
    case 2:
        yield "Bananas";
    default:
        yield "Apples and bananas";
});

Exclude list

Allows you to specify methods for which inlay hints will not be displayed.

Method chains

Method chain hints provide you with the information on the return type of each method in a method chain. The Minimal unique type count to show hints option controls the minimum number of calls required for method chain hints to appear. Hints are only displayed when methods are called at separate lines.

String id = accountManager
    .getAccounts()  // returns ArrayList
    .get(i)         // returns Account
    .getId()        // returns UUID
    .toString();    // returns String

Only unique return types count. This means that hints will not be displayed for straightforward chains such as: 

new StringBuilder("J")
    .append("a")
    .append("v")
    .append("a")

Implicit types

Toggles the visibility of hints for inferred types, for example:

class HintsDemo {

    public static void main(String[] args) {
        var list = getList(); // List<String> is inferred
    }

    private static List<String> getList() {
        return Arrays.asList("hello", "world");
    }
}

Annotations

Inferred annotations

Toggles the visibility of inlay hints for inferred annotations.

External annotations

Toggles the visibility of inlay hints for external annotations.

Code Vision

Usages

Toggles the visibility of usage counters near class, interface, field, and method declarations.

Inheritors

Toggles the visibility of implementation counters near class, interface, and method declarations.

Related problems

Toggles the visibility of inlay hints for problems related to signature changes in classes, methods, or fields that have external usages.

URL path inlay

Controls whether an inlay hint should appear at URL mappings allowing you to quickly access the related actions.

Url inlay java