Problem

The void_function_in_ternary rule incorrectly flags ternary expressions that are used as the return value of an if or switch expression (Swift 5.9+). When a ternary is the sole expression in a branch of an if/switch expression that itself serves as an implicit return value, its result is being used — so the rule should not flag it.

Minimal reproducer:

// False positive: ternary inside if expression used as function's implicit return
func makeValue() -> MyStruct {
    if condition {
        flag ? MyStruct(value: 0) : MyStruct(value: 1)  // void_function_in_ternary warning — incorrect
    } else {
        MyStruct(value: 2)
    }
}

// False positive: ternary inside switch expression used as function's implicit return
func computeSize(for section: Int) -> CGSize {
    switch section {
    case 0: isEditing ? CGSize(width: 150, height: 20) : CGSize(width: 100, height: 20)  // warning — incorrect
    default: .zero
    }
}

Related reports: #5611

Root Cause

The rule determines whether a ternary is a "void call" by checking whether its containing CodeBlockItemSyntax is in an implicit return position (via isImplicitReturn). However, isImplicitReturn only checked for:

• Single-expression closures
• Single-expression functions
• Single-expression variable computed bodies
• Single-expression subscripts / accessors

It did not account for a ternary being the sole expression inside a branch of an if or switch expression that itself occupies one of those implicit-return positions.

Solution

Added a new computed property isIfExprOrSwitchExprImplicitReturn to the CodeBlockItemSyntax extension. It walks up the syntax tree:

• if expression branch — CodeBlockItemListSyntax → CodeBlockSyntax → IfExprSyntax — and then checks whether the IfExprSyntax's own containing CodeBlockItemSyntax satisfies isImplicitReturn (recursively, to handle nesting).
• switch expression case — CodeBlockItemListSyntax → SwitchCaseSyntax → SwitchCaseListSyntax → SwitchExprSyntax — and applies the same recursive check on the SwitchExprSyntax's container.

This correctly handles arbitrarily nested if/switch expressions inside any implicit-return context (functions, closures, computed properties, subscripts, accessors).

Testing

Two new non-triggering examples were added to VoidFunctionInTernaryConditionRule.description:

1. A ternary inside an if expression branch that is the function's implicit return.
2. A ternary inside a switch expression case that is the function's implicit return.

The existing triggering examples remain unchanged, ensuring that legitimate void-function ternaries (e.g. ternaries with additional statements following them in the same block) are still caught.

Fixes #5611