Why is this an issue?
In Kotlin, if and when statements are expressions that return a value. This allows for a more concise and functional
programming style with less cognitive complexity, because it results in fewer return points and fewer variable assignments in a function.
If both branches of an if statement end with a return statement, the if statement should be used instead as
an expression for a return statement.
If all branches of an exhaustive when statement end with a return statement, the when statement should be
used instead as an expression for a return statement. A when statement is exhaustive when it covers all elements of an enum
or features an else clause.
What is the potential impact?
Readability and Understanding
This change makes it easier to understand a function because it will reduce its complexity. This is because the function now contains fewer return
points that the developer needs to keep track of.
How to fix it
Use the if statement as an expression for a return statement. Lift the return keyword from the end of the
if band else branch before the if keyword.
Use the when statement as an expression for a return statement. Lift the return keyword from the end of all
its case clauses before the when keyword.
Code examples
Noncompliant code example
fun returnIfElse(value: Int): String {
// ...
if (value >= 0) { // Noncompliant, every branch contains a return statement
return "positive"
} else {
return "negative"
}
}
Compliant solution
fun returnIfElse(value: Int): String {
// ...
return if (value >= 0) { // Compliant
"positive"
} else {
"negative"
}
}
Noncompliant code example
fun returnWhenElse(a: Float): Int {
// ...
when { // Noncompliant, every branch of exhaustive `when` contains a return statement
a < 0 -> return -1
a > 0 -> return 1
else -> return 0
}
}
Compliant solution
fun returnWhenElse(a: Float): Int {
// ...
return when { // Compliant
a < 0 -> -1
a > 0 -> 1
else -> 0
}
}
Noncompliant code example
enum class OneTwoThree {
ONE,
TWO,
THREE
}
fun returnWhenEnum(oneTwoThree: OneTwoThree): String {
// ...
when(oneTwoThree) { // Noncompliant, every branch of exhaustive `when` contains a return statement
OneTwoThree.ONE -> return "one"
OneTwoThree.TWO -> return "two"
OneTwoThree.THREE -> return "three"
}
}
Compliant solution
fun returnWhenEnum(oneTwoThree: OneTwoThree): String {
// ...
return when(oneTwoThree) { // Compliant
OneTwoThree.ONE -> "one"
OneTwoThree.TWO -> "two"
OneTwoThree.THREE -> "three"
}
}
Noncompliant code example
fun returnIfElseWithSideEffects(a: Float, b: Float): Int {
// ...
if (a < 0) { // Noncompliant, every branch contains a return statement
foo()
return -1
} else if (a > b) {
bar()
return 1
} else {
return 0
}
}
Compliant solution
fun returnIfElseWithSideEffects(a: Float, b: Float): Int {
// ...
return if (a < 0) { // Compliant
foo()
-1
} else if (a > b) {
bar()
1
} else {
0
}
}
Resources
Documentation
Articles & blog posts
