With latest Swift from main, things go differently. We still bind the first IUO first:

let result = Int? + _ + _ + _ + _ + _

But before we select the next disjunction, we run the new disjunction pruning pass. Since + has no overloads where the first argument matches the type "Int?", we end up disabling all active choices in the first + disjunction.

Now, disjunction selection sees that one of the remaining disjunctions has zero active choices. This means the current partial solution cannot be extended to a full solution no matter what choices we make, so we backtrack.

We attempt the next choice in the first IUO:

let result = Int + _ + _ + _ + _ + _

This time, some choices from the first + disjunction are pruned, but nothing fails. We select the second IUO disjunction:

let result = Int + Int? + _ + _ + _ + _

With these choices so far, pruning is again able to detect that there are no suitable choices for the first + that take an "Int" and an "Int?", so we are left with zero active choices and we attempt the second choice in the second IUO:

let result = Int + Int + _ + _ + _ + _

This continues:

let result = Int + Int + Int? + _ + _ + _
let result = Int + Int + Int + _ + _ + _
let result = Int + Int + Int + Int? + _ + _
let result = Int + Int + Int + Int + _ + _
...
let result = Int + Int + Int + Int + Int + Int

At this stage, we've bound all the IUO disjunctions in linear time, and only the + disjunctions remain.

The optimizations that were already existing in Swift 6.3 take over. Disjunction selection favors the (Int, Int) -> Int overload choice in each +, these favored choices succeed, and the rest of the problem is solved without further backtracking.