[CSBindings] Make it possible to enumerate supertypes of existentials

- Drop `mayHaveSuperclass` because it's too restrictive.
- Add logic to get superclass of existential and re-create
  existential type with all of the protocol requirements.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -2172,10 +2172,43 @@ static Type getOptionalSuperclass(Type type) {
     type = underlying;
   }
 
-  if (!type->mayHaveSuperclass())
-    return Type();
+  Type superclass;
+  if (auto *existential = type->getAs<ExistentialType>()) {
+    auto constraintTy = existential->getConstraintType();
+    if (auto *compositionTy = constraintTy->getAs<ProtocolCompositionType>()) {
+      SmallVector<Type, 2> members;
+      bool found = false;
+      // Preserve all of the protocol requirements of the type i.e.
+      // if the type was `any B & P` where `B : A` the supertype is
+      // going to be `any A & P`.
+      //
+      // This is especially important for Sendable key paths because
+      // to reserve sendability of the original type.
+      for (auto member : compositionTy->getMembers()) {
+        if (member->getClassOrBoundGenericClass()) {
+          member = member->getSuperclass();
+          if (!member)
+            return Type();
+          found = true;
+        }
+        members.push_back(member);
+      }
+
+      if (!found)
+        return Type();
+
+      superclass = ExistentialType::get(
+          ProtocolCompositionType::get(type->getASTContext(), members,
+                                       compositionTy->hasExplicitAnyObject()));
+    } else {
+      // Avoid producing superclass for situations like `any P` where `P` is
+      // `protocol P : C`.
+      return Type();
+    }
+  } else {
+    superclass = type->getSuperclass();
+  }
 
-  auto superclass = type->getSuperclass();
   if (!superclass)
     return Type();
 

test/Concurrency/sendable_keypaths.swift

@@ -200,3 +200,20 @@ func testReferencesToDifferentGlobalActorIsolatedMembers() {
     // expected-warning@-1 {{cannot form key path to main actor-isolated property 'name'; this is an error in Swift 6}}
   }
 }
+
+do {
+  struct S {
+    var a: Int
+    var b: String?
+  }
+
+  func test<T: Sendable>(_: T) {}
+
+  let kp = [\S.a, \S.b]
+
+  test(kp) // Ok
+  test([\S.a, \S.b]) // Ok
+
+  let _: [PartialKeyPath<S>] = [\.a, \.b] // Ok
+  let _: [any PartialKeyPath<S> & Sendable] = [\.a, \.b] // Ok
+}