The SIL here is identical, so the compiler consider these to be the same, at least on 64-bit platforms. This is what I'd expect: as you say, the compiler is forewarned that these two operations will be absolutely isomorphic.
If either of these ever fails to generate a simple in-register zero-extension when optimized, that's a performance bug. So they should be equivalent. As @lukasa noted, you can check this on Godbolt; here's a link showing an example: Compiler Explorer
Here's the code from that example:
public func foo(x: UInt32, y: UInt32) -> Int {
return Int(truncatingIfNeeded: x) + Int(y)
}
and the generated assembly, annotated with my notes explaining what's happening:
// Standard stack frame setup. Arguably Swift should be able
// to omit the frame for simple leaf functions like this.
push rbp
mov rbp, rsp
// Zero-extend `x` and `y` by using a 32b `mov` instruction, which
// implicitly zero-extends to 64b.
mov ecx, edi
mov eax, esi
// Add the two zero-extended values as 64b integers.
add rax, rcx
// Clear stack frame and return
pop rbp
ret