When to use single-line if statements?

Question

When reviewing code, I prefer to read if statements that explicitly demonstrate that a fork in code execution may occur:

if ( isFoo(baz) ) {
    runBar();
}

When scanning hundreds of lines of the nonindented version, it is not obvious that a conditional may or may not occur:

boom += 1;
baz = getBaz(boom);
if (isFoo(baz)) runBar();
boing = boom + baz;

So when is it considered all right to single-line if statements? I'm willing to put up with it if the conditional is on a die(), return, or exception, because in those cases at least the current method ends.

if (isFoo(baz)) die("No more foo!");

Are there any other "good" uses for single-line if statements? How strictly should the practice be avoided? Note that I am explicitly asking about the lack of an indented line to indicate that a condition may or may not occur, I am not asking about the use of braces. Although I would appreciate all opinions in the comments, answers should address objective reasoning, such as maintainability or extensibility of code.

This is not a dupe of Single statement if block - braces or no because this question does not ask about braces. This is not a dupe of Single Line Statements & Good Practices because that question does not address the crux of this question: the ability to determine that some lines of code may or may not be run, thus leading to divergent code paths.

Answer 1

The only time to use a single-line if statement is when you have a lot of them and you can format your code to make it very clear what is happening. Anything else is not clear and will lead to errors.

eg.

if (x) do_stuff();

is terrible. When mixed in with other code, it does not clearly show the conditional statement, and some people will confuse the following line as a badly-indented conditional. This applies to all statements, especially if they are die(), return or throw. It has nothing to do with the running of the code, its all about the readability.

if (a) do_a();
if (b) do_b();
if (c) do_c();

this is much better than putting the conditionals on the next line as its clearer what is intended, there is no scope for confusion.

Answer 2

I always prefer the version with braces.

1. If I don't always use the braces, then I may forget to put them when there is more than one statement in the block.
2. IDEs used by other team members can reformat the code automatically to move the statement to the new line, thus making it much more error prone in the future.
3. Merging the code across the branches is more error prone if the if statement is a conflicting spot. The probability for error is even higher if the person doing the merge is not completely familiar with the merged changes.
4. A statement not-belonging to the block may be included in it later by mistake (I add new statements to the block, so I need to add braces, but because of indentation or similar visual effects I also include a statement that should be left out of the block).

Answer 3

I would propose an alternative answer. I prefer single liners when the condition inside is really a single line and is relatively isolated from the rest of the conditions.

One great example is:

public void DoSomething(int something) {
     // Notice how easily we can state in one line that we should exit the method if our int is 0.
     if(something == 0) return;

     CallAnotherMethodHere(something);
}

A bad example(in my opinion) would be what @gbjbaanb mentioned:

if (a) do_a();
if (b) do_b();
if (c) do_c();

To me, this is a switch statement and should be written as such:

switch(something) {
    case "a":
        do_something_to_a();
        break;
    case "b":
        do_something_to_b();
        break;
    case "c":
        do_something_to_c();
        break;
    default:
        break;
}

Much more readable IMHO and more efficient as variable needs to be evaluated only once VS running through all the if statements although gains are negligible.