[formatting] if without brace does not indent on next line when typing return

Hi Jim. This is a known issue. The implementation of auto indentation on newline presses is trying to strike a balance between something that is

1) relatively straightforward to implement
2) robust when code is not completely syntactically correct
3) works in the most common cases so it is not annoying

Unfortunately, number 2 means that I decided explicitly not to use the Groovy parser, but mostly use some heuristics based on braces. This will work, as you noticed, ok when braces are there but not so well when they are not.

I figured that having to press "tab" to fix indent in these (I hope uncommon) cases is a fair price to pay for having the newline indentation logic work, even when the file has syntax / parse errors in it.

I do agree with you though. Ideally, this sort of case should be handled somehow.

We'll keep this issue open, it's something I'm keeping in the back of my mind, maybe when I get a good idea sometime how to handle this without doing a full parse, this can be fixed.

Thanks for submitting your report. Even though this was a "known issue", having user submitted issues/comments helps us gauge the importance of an issue.

Thanks Kris, I hope you can fix it.

I know it is tricky to fix as I implemented it for the Groovy emacs mode, and handling no ; and indentation after no braces was one of the harder things to do, but it is doable if you can keep state for at least one previous line, the same thing applies to an else without a brace. The groovy emacs mode is based on the java/cc-mode, and both expect ; to terminate statements, the hack that was used to get around that is what was used in Groovy mode, and is a pain to maintain, and it is not perfect, but for the most part works most of the time.

I've put quite a bit of thought into this. The tricky part is not so much to indent the statement inside the if... the really tricky part is how to know when and how far to jump back when a statement finishes.

Example:

public class Blah {
    void dothat(def a, def b) {
	if (a<b)
	    if (a<b)
                blah()<***>
    }
}

How far do we need to jump back when pressing return at the <***> position?
Since the if's can be arbitrarily deeply nested, we may need to scan backwards
arbitrarily far, effectively doing a kind of "backwards parsing" of the text
before the <***>.

Implementing this well, would mean almost rewriting the current simplified logic based on simple brace matching and replacing it with something far more complex. I'm not sure this is really worth it.

Unless we get feedback that this glitch in indenting of ifs without braces is a real nuisance to people, I intend not to fix this issue.

Actually, something I could easily do, is implement a hack that indents the statement after the if automatically, but does not automatically jump back when that statement ends.

I'm not sure this a good idea, but it would reduce the number of "manual corrections" users have to do while typing ifs without braces by 50%. So in some sense it would make the problem smaller.

IMHO this would be worse as the most common usage I have is...

    if(something)
        dosomethimg
    else
        dosomethingelse

It is unfortunate that this will not be fixed as every other editor can handle this case, making the groovy eclipse editor definitely substandard compared to the others.

In answer to your question about how for to jump back I'd say you always jump back one indent level, as the case proposed above is very rare an most people would use braces in those more complicated cases. The most common use of not using braces is with one liners as above

Good points Jim. Thanks!

It may be worthwhile and not too hard to try and do something that works well enough for the common case with one liners. I'm reopening the issue and will have a look at it when I get some time.

Another idea is for the "else" to automatically jump back to align with matching if as soon as you finish typing "else". This is not hard to implement at all.

I'd say the best strategy is to always deindent the following line after the one line statement, regardless of whether it is an else, but remember that else will indent the following line just like an if does, and deindents the line after that, the ruls if if and else in these cases is identical.

Basically what I did in emacs was to detect an if without a brace indent the next line and deindent the line following that, ditto for else without a brace.

Yes, and we also have similar cases for statements like "while" and "for"

while (a < len)
    doSomething(a++)
doneit()