Ambiguous generic type extensions

Using Swift
1

When extending a type with and without a constraint on it's generic parameter compiler considers expressions ambiguous without explicit type annotations

struct Foo<A> {}

extension Foo {
    var string: Foo<(A, String)> {
        return Foo<(A, String)>()
    }
}

extension Foo where A == Void {
    var string: Foo<String> {
        return Foo<String>()
    }
}

// ambiguous use of 'string'
let foo = Foo<Void>().string

// compiles, but shouldn't be possible
let foo1: Foo<(Void, String)> = Foo<Void>().string

// compiles, but requires explicit type annotation
let foo2: Foo<String> = Foo<Void>().string

// for some reason this is resolved fine as Foo<String>...
let foo3: Foo = Foo().string

Is there a way to avoid this and at the same time not to allow possibility to have Foo<(Void, String)> values?

What confuses me is that compiler does not pick more constrained extension and that the last variant (foo3) does not result in ambiguity at all though it has no types specified, but the first with explicit type (foo) is at the same time ambiguous

Ref: Feedback Assistant