Is there an official (documented) stance on how to...

# getting-started

[Vampire]

Is there an official (documented) stance on how to format continuation lines on wrapped expressions?
I don't find anything in the official coding conventions page.
The only thing I found there is one wrapped expression but it is within an if condition and that is a special case that is also treated differently in the IDE.
ktlint seems to use 4 spaces in that case.
But IntelliJ by default uses 8 spaces as continuation indent.
On the other hand, using "Set from ... -> Kotlin style guide" does not change the continuation indent value at all.

[CLOVIS]

The IntelliJ defaults are the "old" code style, it's kept as a default to avoid breaking old projects. The recommended config is the "new" code style.

[Vampire]

Thanks, but that doesn't answer my question at all.
I neither found an official recommendation for the continuation indent for example when wrapping expressions.
Neither does it get configured to any value when slecting "Set from ... -> Kotlin style guide" which is the new one.

[CLOVIS]

The current coding style is to use a normal indent for continuation:

val foo =
    if (...) ...
    else ...

[Vampire]

I'm specifically asking for wrapped expressions, for example

val foo = !true &&
        !true

vs.

val foo = !true &&
    !true

or

.filter { line ->
    (line == "a") ||
            (line == "b")
}

vs.

.filter { line ->
    (line == "a") ||
        (line == "b")
}

And my main question is not how the convention is, but where it is documented. I do not find this case documented on the conventions page.

[CLOVIS]

I don't think it's explicitly written anywhere, but you can find a lot of examples in the style guide that demonstrate that it must be 4 spaces:

class Person(
    id: Int,                     // HERE
    name: String,
    surname: String
) : Human(id, name),
    KotlinMaker { /*...*/ }      // HERE

fun longMethodName(
    argument: ArgumentType = defaultValue,    // HERE
    argument2: AnotherArgumentType,
): ReturnType {
    // body
}

fun f(x: String, y: String, z: String) =
    veryLongFunctionCallWithManyWords(andLongParametersToo(), x, y, z)        // HERE

if (!component.isSyncing &&
    !hasAnyKotlinRuntimeInScope(module)       // HERE
) {
    return createKotlinNotConfiguredPanel(module)
}

private fun parsePropertyValue(propName: String, token: Token) {
    when (token) {
        is Token.ValueToken ->
            callback.visitValue(propName, token.value)                        // HERE

        Token.LBRACE -> { // ...
        }
    }
}

etc

[Vampire]

All the examples you listed and all I find in the docs do not apply.
All those examples have explicit handling that is also not influenced by the "continuation indent" setting.

The examples I showed use the "continuation indent" setting and those are in no form shown in the docs page.

The closest thing is the if condition, but that one has special handling and is also not influenced by the "continuation indent" setting.

[CLOVIS]

Ah, my bad, I was convinced that's what continuation indent did.

[Vampire]

As practically everywhere only one indent (4 spaces) is used, I also guess it indeed is also intended there.

But I'm after an official documented stance on it or report a doc bug.
And especially as the "import from official style" does not change the continuation indent value which would then maybe an additional code bug. 🙂