"branches have mismatching types" in recursive computed property when using single-expr implicit return; works fine with explicit return in each branch

[lukaskollmer]

Description

In the program below, the first computed property (using implicit returns) fails to compile, while the second one (using explicit returns) works fine.

since the two are semantically equivalent, the compiler should be able to compile both.

Reproduction

final class Entry {
    var prev: Entry?
    var next: Entry?
    
    var history: some Sequence<Entry> {
        // error: Branches have mismatching types 'some Sequence<Entry>' and 'UnfoldSequence<Entry, (Entry?, Bool)>'
        if let prev {
            prev.history2
        } else {
            sequence(first: self, next: \.next)
        }
    }
    
    var history2: some Sequence<Entry> {
        // fine
        if let prev {
            return prev.history2
        } else {
            return sequence(first: self, next: \.next)
        }
    }
}

Expected behavior

the compiler should treat both equally: since it apparently is already able to understand that the explicit-return version will have the same return type in each branch (bc one branch returns a concrete type, and the other is recursive and will therefore eventually also return that type), it should do the same for the implicit-return version

Environment

swift-driver version: 1.115.1 Apple Swift version 6.0.3 (swiftlang-6.0.3.1.10 clang-1600.0.30.1)
Target: arm64-apple-macosx15.0

Additional information

No response