Visual Studio Code – How to disable automatic adding of opening parenthesis in on autocomplete with the VS Code Java Language Support extension?

In VSCode if you type Java code such as this …

new ArrayList(

… while using autocomplete you end up with:

new ArrayList<>((

Some kind of "feature" is automatically adding parentheses. However, this "feature" interferes with regular flow of typing and therefore is extremely annoying.

Edit:

Sorry, as I use autocomplete automatically now for decades, I forgot to mention this in the original text above. It is so naturally to use it, at some point you stop thinking about it. Perhaps that was the reason for the confusion surrounding this question.

However, you start thinking about autocomplete only if it does not behave as you might expect it to behave. That’s what this question is about.

I’ll try to explain the problem in more detail in the next sections.

The typical Java situation

As I mentioned above to reproduce this behavior you only need to type the name of class within a code block, e.g. something like this:

The underscore marks the position of the cursor.

(Sorry, I’m not capable of fancy animations, so instead I use tables with each editing step to depict the situation here.)

As you can see above: In contrast to other autocomplete implementations for VSCode some special "feature" in the Red Hat Java extension adds parenthesis automatically.

The Python (and C) situation

Interestingly in other programming languages – e.g. Python – the autocomplete feature is implemented differently:

So after autocomplete there is no additional parenthesis inserted. In contrast to the same code situation in Java. ArrayList and ASTNode are both classes. However, autocomplete behaves differently in both cases.

More insights into Java autocomplete

Consider these primitive class definitions:

public class Class1 {
    public Class1(int foo) {
    }
}

public class Class0 {
}

If you try to instantiate Class1 within a method autocomplete behaves like this:

However if you try to instantiate Class0:

So the placement of the cursor is inconsistent: It depends on the kind of constructor(s) present in the class.

Even more insights into Java autocomplete

And it’s even more complicated. Consider this example:

public class Test
{

    public static void foo()
    {
    }

    public static void main(String[] args)
    {
        _
    }

}

The underscore marks the cursor position. Now if you’re at this position and type …

In this situation autocomplete is behaving completely differently again and even adds a semicolon.

However, if you do the equivalent in C no parenthesis (and no semicolon) are added at all.

I stop here and do not analyze more programming languages for now as it would bring us to far away from the question.

The question

Autocomplete behaving differently in different situations (and differently across different languages) is not very helpful. So the question is:

Can this kind of autocomplete "feature" be configured somehow? (Here: For the Java extension.) Can this "feature" that is trying to add parenthesis be deactivated somehow? (Because to my experience this is the most common situation.)

(And of course: Without losing autocomplete all together. Just deactivating Java language support all together is not an option.)

I was not able to find anything in the settings. I was not able to find anything on Google (so far) – but maybe you have. Do you know a way how to modify (= streamline) this behavior? I’m interested in having a more consistent behavior across different programming languages. I know there are fine grained configurations in other IDEs so I guess there is a way to configure this in VSCode as well. But how?