Scoping blocks reformatted to invalid Kotlin

Scoping blocks ({ val doesntEscapeScope }) are reformatted by ktfmt to cause semantically different Kotlin, leading to a compiler error or production bug. For example:

someMethod()

{
   // do some things in a scope
}

becomes:

someMethod() {
  // do some things in a lambda argument to someMethod
}

Even worse, because of trailing semicolon stripping, there is no way for the author to prevent this behavior:

someMethod();

{
   // do some things in a scope
}

is semantically equivalent to

someMethod(); {
  // do some things in a scope
}

but becomes the aforementioned

someMethod() {
  // do some things in a lambda argument to someMethod
}

[aragos]

Thanks for the heads up! The “unused lambda” situation is indeed very problematic - while it is a compiler warning it seems severe enough that we’re looking to ban it via lint check in our codebase.

Meanwhile, there are some legitimate cases where the formatter still creates problems, such as this:

fun returnDeferredLambda(): Deferred<Input -> Output> =
  async {
    val values = do_async_things()
    { input -> turn_input_to_output(input, values) }
  }

Here the “standalone” lambda is the return value of the async call and should not be treated as an argument to do_async_things.

So if you could help in addressing them that would be much appreciated!

[strulovich]

Sorry for the delay, took a look today. Kotlin considers this lambda to be an argument to the function call, no matter the spacing.

I tried writing an simpler example for it:

fun main() {
    f {
        println("1")
        val l = { println("2") }
        l // this is ok
    }
    f {
        println("3")
        { println("4") } // this does not compile:
        // Type mismatch: inferred type is Unit but () -> Unit was expected
        // Type mismatch: inferred type is Unit but () -> Unit was expected
        // Too many arguments for public inline fun println(): Unit defined in kotlin.io
        // Expression is treated as a trailing lambda argument; consider separating it from call with semicolon
    }
}

fun f(block: () -> (() -> Unit)) {
    val innerBlock = block.invoke()
    innerBlock.invoke()
}