Swift中for _ in [1,2,3]是否会不执行？为何编译器报缺返回？

Great question! Let's break down why your code func f() -> Int { for _ in [1,2,3] { return 1 } } throws a "missing return" error, even though logically the loop will always run at least once—and why cases like if 1 < 2 { return 1 } or while true { return 1 } work fine.

Key Differences in Compiler Path Analysis #

First, let's clarify how Swift's compiler checks for exhaustive code paths:

• Constant Boolean Expressions: Cases like if 1 < 2 or while true use expressions that the compiler can evaluate at compile time to be definitely true. These are treated as unconditional branches—Swift knows the code inside will always run, so it doesn't require a fallback return outside the branch.
• For-Loops Over Collections: Even when you use a literal array like [1,2,3], the compiler doesn't perform the same "non-empty" check at compile time. Here's why:

1. Type System Limitations #

Swift's standard Array type doesn't have a compile-time "non-empty" variant. When you write [1,2,3], the compiler treats it as a regular Array<Int>—not a special type that guarantees at least one element. The compiler's reachability analysis only looks at the type of the collection, not the specific literal value used to initialize it.

2. Consistency in Compile-Time Checks #

The Swift team designed the compiler's reachability rules to be consistent and predictable. If they added an exception for literal arrays, they'd have to extend it to all literal collections (Sets, Dictionaries, etc.), and also handle edge cases like dynamically generated literals (e.g., Array(repeating: 0, count: 3)). To avoid complicating the compiler logic with special cases, they decided to not infer "non-empty" status from any collection initializer—even literal ones.

3. No Runtime Edge Cases (But Compiler Doesn't Assume That) #

To answer your final question: there are no runtime scenarios where for _ in [1,2,3] won't execute. The literal array will always have 3 elements, so the loop body runs at least once. But the compiler doesn't make this assumption because it doesn't tie the collection's runtime contents to its compile-time literal initialization.

How to Fix the Compile Error #

If you want to convince the compiler that the loop will always execute (and thus no fallback return is needed), you can use unreachable() (available in Swift 5.7+) to mark the code path after the loop as unreachable:

func f() -> Int {
    for _ in [1,2,3] {
        return 1
    }
    unreachable() // Tells compiler this path will never be hit
}

Alternatively, you can add a fatalError() as a redundant safety net:

func f() -> Int {
    for _ in [1,2,3] {
        return 1
    }
    fatalError("This code is unreachable")
}

内容的提问来源于stack exchange，提问作者Sweeper