experimental:multiline-if-else treats all if statements as multiline

[pkubowicz]

Expected Behavior

MultiLineIfElseRule.kt respects its own JavaDoc, i.e. quoting Kotlin Coding Conventions:

If the condition of an if or when statement is multiline, always use curly braces around the body of the statement.

Observed Behavior

The current code considers any if statement followed by a newline as needing curly braces.

Steps to Reproduce

        if (System.getenv("foo") != null)
            println("ok")

Your Environment

• Version of ktlint used: 0.37.2
• Name and version (or code for custom task) of integration used (Gradle plugin, Maven plugin, command line, custom Gradle task): Gradle plugin
• Version of Gradle used (if applicable): 6.5.1
• Operating System and version: Linux 5.4.0-40-generic amd64
• Link to your project (if it's a public repository):

[romtsn]

We shouldn't change this when the --android option is passed though, since it is marked as wrong there. Honestly, I'm in favour of Android styleguide in this case, not sure why kotlin's one does not clearly define anything here

[BraisGabin]

Honestly, I'm in favour of Android styleguide in this case, not sure why kotlin's one does not clearly define anything here

Same here. It's a common practice in several languages.

[pkubowicz]

It's a common practice in several languages.

In languages that have C-like syntax. Kotlin has an option to write code in a more functional style.

I don't want to explain Kotlin team decisions as I don't have any knowledge about their reasoning, I may only guess. Take a function:

fun createFoo(arg: Int) =
    "a".repeat(arg)

It's short, consistent and does not use any braces. Now let's evolve this function by making its behaviour dependent on the argument value:

fun createFoo(arg: Int) =
    if (arg < 5)
        throw IllegalArgumentException("Too long to keep the whole method body in 1 line")
    else
        "a".repeat(arg)

One can argue that adding braces to the if statement would make this simple function no longer consistent, no longer functional style but rather having an imperative smell:

fun createFoo(arg: Int) =
    if (arg < 5) {
        throw IllegalArgumentException("Too long to keep whole method body in 1 line")
    } else {
        "a".repeat(arg)
    }

Maybe yes, maybe no – I'm not a functional purist. One can also argue that it's weird to have braces in a function which body does not have braces - there is no closing brace on "level 0". For people used to Java braces style it looks like the code should not compile because there is a closing brace missing.

[romtsn]

Created an issue to get JB's opinion on that (hopefully with the styleguide update) https://youtrack.jetbrains.com/issue/KT-41070

[Kantis]

My 2 cents is that I don't think this is something that needs to be strictly linted. I think the main benefit of using Ktlint is to get rid of formatting changes happening back and forth in PRs which just contribute noise. In this case there's not gonna be any auto formatting, and it can be left to the programmer to decide what best fits the use case.

So my opinion is that all can be considered correct.

if (condition) 1 else 0 // correct

if (condition) // correct
    1
else
    0

if (condition) // correct
    1

if (condition) { // correct
    1
} else {
    0
}

[paul-dingemans]

The new ktlint_official code style contains rules that:

• enforces a multline if statement to wrap each branch in a block
• disallows a single line if statement to have more than one else branch
• disallows a single line if statement to wrap a branch in a block

if (condition) 1 else 0 // allowed

if (condition) { 1 } else 0 // disallowed

if (condition) 1 else if (otherCondition) 2 else 0 // disallowed

if (condition) // disallowed
    1
else
    0

if (condition) // disallowed
    1

if (condition) { // allowed
    1
} else {
    0
}

[Kantis]

@paul-dingemans will this still be allowed?

if (condition) 1
else 0

[paul-dingemans]

No, it is a multiline statement. But if (condition) 1 else 0 is accepted.

[spacemase]

So how does one correctly format this code from above?

fun createFoo(arg: Int) =
    if (arg < 5)
        throw IllegalArgumentException("Too long to keep the whole method body in 1 line")
    else
        "a".repeat(arg)

or worse:

createFoo(arg = 
    if (bar < 5) 
        throw IllegalArgumentException("Too long to keep the conditional on 1 line")
    else 
        0
)

[paul-dingemans]

It depends on your configuration. But running Ktlint CLI (ktlint -F) will show you, what the expected format is.

Given .editorconfig below:

root = true

[{*.kt,*.kts}]
ktlint_code_style = ktlint_official
ktlint_standard = enabled
ktlint_experimental = enabled

the code should be formatted as:

fun createFoo(arg: Int) =
    if (arg < 5) {
        throw IllegalArgumentException("Too long to keep the whole method body in 1 line")
    } else {
        "a".repeat(arg)
    }

fun bar() {
    createFoo(
        arg =
            if (bar < 5) {
                throw IllegalArgumentException("Too long to keep the conditional on 1 line")
            } else {
                0
            },
    )
}

(I have wrapped the second example into function bar() as code is otherwise can not be processed by embedded compiler)

[spacemase]

I did not know the -F flag! THANK YOU for replying on this old thread. Addressing this scenario put me at the peak of frustration.