keyword "some" will be inferred as "any" in Protocol extension function

[miku1958]

Describe the bug
keyword "some" will be inferred as "any" in Protocol extension function

Steps To Reproduce
Steps to reproduce the behavior:

1. using keyword "some" in a Protocol extension function
2. using this function in Generic function

import SwiftUI

protocol Ability { }

extension Ability {
	func image() -> some View {
		Image("").resizable()
	}
}
struct MainAbility: Ability { }

let ability: Ability = MainAbility()
HStack {
	ability.image()
}

Expected behavior
Compiler can build successfully.

Screenshots

Environment (please fill out the following information)

• OS: [e.g. macOS 12.6]
• Xcode 14.1 beta 3 (14B5033e)

[slavapestov]

This is expected behavior. The type of 'ability' is 'any Ability', which is a type-erased existential. Calling a protocol extension method that returns an opaque return type on an existential erases the opaque return type to the existential, because there is no way to represent the result type statically in this case.

Consider this code:

protocol P {}

extension P {
  func foo() -> some P { return self }
}

struct S1: P {}
struct S2: P {}

let s1: any P = S1()
let s2: any P = S2()
let b: Bool = ...
let foo = (b ? s1 : s2).foo()

// what is the type of 'foo'?

[miku1958]

Hi @slavapestov, in your case, foo() return P itself, but in my case, there is no Association between the return type and the protocol itself.

It seems to me that the behavior of the above code and the following code should be equivalent, and the following code is compilable

protocol Ability { }

extension Ability {
}

func image(ability: Ability) -> some View {
	Image("").resizable()
}
struct MainAbility: Ability { }

let ability: Ability = MainAbility()
HStack {
	image(ability: ability)
}

Update to make this "ability" useful

protocol Ability {
	var imageName: String { get }
}

extension Ability {
}

func image(ability: Ability) -> some View {
	Image(ability.imageName).resizable()
}
struct MainAbility: Ability {
	let imageName: String = "plus"
}

let ability: Ability = MainAbility()
HStack {
	image(ability: ability)
}

[AnthonyLatsis]

in my case, there is no Association between the return type and the protocol itself.

To clarify on why this is the current behavior: Similar to a nested type declaration (e.g. X<T>.Y), an opaque type declaration (e.g. X<T>.foo.(opaque result type of 'foo')) implicitly depends on any outer generic parameters (e.g. T). Even if T is not used in the interface of the nested type declaration X<T>.Y, X<Int>.Y and X<Bool>.Y are different types — the generic parameter T is part of its identity. The same is true for an opaque type — whether or not the underlying type depends on any generic parameters does not affect its identity. Why? Because the underlying type, which is an implementation detail by design, can change in the future, and we do not want such a change to break other code or affect the identity of the opaque type at the binary level.

In your case, the declaration of the opaque type some View depends on the protocol’s Self, but we cannot statically represent the Self type of an existential box any P without opening it, so the result gets type-erased before it is passed to the corresponding result builder method. Hence the rather unhelpful error, Type 'any View' cannot conform to 'View'.

---

HStack {
  ability.image()
}

It should be possible to make this work by extending SE-0352 to result-builder-transformed contexts.