Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 2 Next »

There are three completion types:

Logical name




Smart (SmartType)


Class Name


Pressing the same shortcut twice results in 'second' completion, which may give more variants.

You may choose item in completion list not only with Enter, but also with variety of other keys: space, dot, colon, semicolon, '(' etc. Basically this will result in inserting that character after the completed identifier, but sometimes more wil be done. For example, finishing Java method call with '(' will, of course, insert also ')'.

Choosing item with Tab has special meaning. In this case, if you are inside identifier, it will be overwritten completely instead of just inserting the item string into caret position.



  • Context-specific reference and keyword completion, inserts parentheses, semicolons etc. where necessary.
  • Second:
    • Inaccessible members (e.g. private fields) are shown.
    • If prefix starts with an uppercase letter, shows all classes (like Class Name completion). Suggested in first completion invocation if there were no matching variants.


  • Performs reference variants filtering based on expected type. If say an int is expected, only the variables/fields/methods of int type will be suggested.
  • If there is a one-element array of expected type (like the one created automatically to communicate with inner classes), and its name is say ref, then ref[0] is completed.
  • After new suggests all the classes descending from the expected type, inserts parentheses, if the selected class is abstract, will generate anonymous class body and suggest methods to implement.
  • After throw new suggests only the non-runtime exceptions merged with those explicitly declared in throws-clause.
  • In Javadoc throws tag suggests exceptions from method's throws-clause.
  • After catch suggests the exceptions that are thrown inside try.
  • After instanceof suggests inheritors of the checked expression type.
  • When Class<? extends X> is expected, suggests Class<Y> for all Y inheriting from X.
  • Completes generic parameters where missing: List<String> l = new ArrayList<|>();
  • Inserts explicit method type parameters where necessary: collect(Collections.emptyLis|) where collect expects List<String>
  • Suggests to cast to expected type after opening parenthesis: String s = (|
  • When calling a method or constructor with matching signature (e.g. a super method), fills all the parameters immediately.
  • Suggests live templates with statically-determineable type and 'Smart completion' checkbox on.
  • Searches expected class's static members for matching values: Singleton s = | will result in Singleton s = Singleton.getInstance();
  • Analyzes dataflow in search for typecasts and *instanceof*s and suggests to cast expressions to expected type where possible.
  • Keywords:
    • Adds .class if Class is expected.
    • Suggests this. If accessing outer class instance, qualifies it.
    • true, false
    • null if there's a non-empty matching prefix and there are no other variants.
  • Second:
    • Iterates over the visible methods/fields to check if their return value contains members of expected type, resulting in chained calls like getModule().getProject(). Prefix matching is done on both the first and the second member in chain (so you may get this result from both getMo| and getPro|).
    • Converts between arrays and lists when you have one in context and need another.
    • Adds array member accessors when you have an array of expected type: int a = | will result in int a = intArray[|].

Basic & Smart

  • When completing a qualified expression analyzes dataflow and checks if there are any typecasts or *instanceof*s concerning the qualifier. If yes, suggests the variants based on the casted type and inserts the cast automatically.
  • In debugger's Evaluate Expression dialog does similar casting to runtime type. When expression is simple variable/field access, it's done immediately, when it involves method calls, on second completion.
  • If all variants are method overloads with the same name, lookup isn't shown, method name is inserted with caret placed inside parentheses.
  • When completing a method with boolean return type, you may finish completion with '!' and the call result will be negated.
  • You may finish completion with Complete Current Statement action (Ctrl+Shift+Enter), which will attempt to syntactically correct your code, e.g. wrap the following expression into parentheses if you've chosen a method call.

Class Name

  • Suggest all the classes visible from current code location.
  • On second invocation suggests all the classes that may become visible if you change their access modifiers or add necessary module dependencies.
  • After new also inserts parentheses for constructor invocation.
  • No labels