[SR-12829] Switching over a tuple unnecessarily materializes the tuple

[belkadan]

Previous ID	SR-12829
Radar	None
Original Reporter	@belkadan
Type	Improvement

Additional Detail from JIRA

Votes	0
Component/s	Compiler
Labels	Improvement
Assignee	None
Priority	Medium

md5: a79f917a0c3cfcae0dcddba3f764690b

Issue Description:

Comparing the output of the following two functions, the version that switches over a tuple forms the tuple in memory even though it's never used in aggregate. The compiler should be able to optimize the tuple away completely, since it is only formed, switched upon, and deconstructed.

public func tuple<T: Equatable>(a: T?, b: T?) -> Bool {
    switch (a, b) {
    case (nil, nil): return true
    case (.some(let x), .some(let y)): return x == y
    default: break
    }
    return false
}

public func nested<T: Equatable>(a: T?, b: T?) -> Bool {
    switch a {
    case nil:
        switch b {
        case nil: return true
        default: break
        }
    case .some(let x):
        switch b {
        case .some(let y): return x == y
        default: break
        }
    }
    return false
}