Unexpected failure to open constrained existential

[KeithBauerANZ]

Description

class C {}

protocol P<A> {
    associatedtype A
    func apply(to a: A)
}

struct S<A: C> {
    var ps: [any P<A>]

    func doThings(to a: A) {
        for p in ps {
            p.apply(to: a)
        }
    }
}

FailureToOpen.swift:13:13: error: member 'apply' cannot be used on value of type 'any P<A>'; consider using a generic constraint instead
            p.apply(to: a)
            ^ ~~~~~

Removing the constraint A: C allows the code to compile.

Replacing the direct call to the protocol function with something that opens the existential in argument position produces a different error (that makes me want to slap the compiler for being oblivious to the obvious):

class C {}

protocol P<A> {
    associatedtype A
    func apply(to a: A)
}

struct S<A: C> {
    var ps: [any P<A>]

    func do1Thing(p: some P<A>, to a: A) {
        p.apply(to: a)
    }

    func doThings(to a: A) {
        for p in ps {
            do1Thing(p: p, to: a)
        }
    }
}

FailureToOpen.swift:17:13: error: instance method 'do1Thing(p:to:)' requires the types 'A' and '(some P<A>).A' be equivalent
            do1Thing(p: p, to: a)
            ^
FailureToOpen.swift:11:10: note: where 'A' = 'A'
    func do1Thing(p: some P<A>, to a: A) {
         ^

Expected behavior

Pretty sure both these samples should compile; the constraint of the struct's generic argument shouldn't affect opening to the less-constrained protocol.

(When I originally encountered this, the protocol also had a constraint of the associated type to AnyObject; that doesn't seem relevant to the test case but might be to the general solution?)

Environment
swift-driver version: 1.75.2 Apple Swift version 5.8 (swiftlang-5.8.0.124.2 clang-1403.0.22.11.100)
Target: arm64-apple-macosx13.0

[KeithBauerANZ]

Behaves the same with Xcode 15b2:

swift-driver version: 1.82.2 Apple Swift version 5.9 (swiftlang-5.9.0.114.10 clang-1500.0.29.1)
Target: arm64-apple-macosx13.0

[AnthonyLatsis]

Shorter:

• Existential member access:

  class C {}
  
  protocol P<A> {
    associatedtype A
    func apply(_: A)
  }
  
  func test<A: C>(p: any P<A>, a: A) {
    p.apply(a)
  }

• Implicit existential opening:

  class C {}
  
  protocol P<A> {
    associatedtype A
  }
  
  struct S<A: C> {
    func generic(p: some P<A>, a: A) {}
  
    func existential(p: any P<A>, a: A) {
      generic(p: p, a: a)
    }
  }

Tested with 23e2f34.