Unused return value checker

[sandwwraith]

This is a place to discuss Unused return value checker proposal. The text of the proposal is located here.

This proposal depends on the other sub-proposal, Underscore for unused local variables, located here.
Since both proposals are connected, we'll discuss them together.

The goal of the proposals is to enhance the functionality of the existing 'unused expression' diagnostic in the Kotlin compiler.
New diagnostic should be able to report complex expressions whose return values are meaningful (e.g., non-Unit) but are not used.

This discussion is a follow-up to the previous KEEP discussion format. See previous comments in the issue.

Checker is ready to try in Kotlin 2.3.0 starting from Beta1.

[netdpb]

In the Expression return value usage section, it says a return value A is used when A is "the last statement in lambda" and gives list.map { A } as an example.

I don't think that's true for all lambdas. Specifically, Unit-returning lambdas don't use their last expression. For example, I don't think foo.apply { A } uses A even though it's the last statement.

[sandwwraith]

That's a great observation! Indeed, when Unit coercion happens inside the lambda the resulting value may be lost. Our checker is able to report such cases (see https://youtrack.jetbrains.com/issue/KT-74860 for details).

[netdpb]

It seems inconsistent that boolean operators like || don't have to be used if the right-hand operand has Nothing type but not the elvis operator.

something() ?: return and something() || return seem very similar. In fact the former is equivalent to something() == null || return, which wouldn't produce a warning.

But the former will produce a warning and the latter won't. Why make those cases different?

[sandwwraith]

something() ?: return and something() || return seem very similar.

Yes and no. LHS of Elvis can be any nullable type, while LHS of || is always a Boolean type. IMO, it is more dangerous to lose arbitrary value instead of just Boolean true/false value.
However, this rule came from studying how Kotlin code is written: majority of people use val x = something() ?: return, so lack of val x is almost always is a mistake. On the other hand, if || has Nothing as RHS, it is rarely assigned to a variable, so the Boolean result is used exclusively for control flow.

[netdpb]

OK. It might be worthwhile to update the KEEP to explain why there's this apparent inconsistency.

[pdvrieze]

Also for the || operator, once a right hand side returns the value of the function is actually known for the non-returning path. It is a constant true.