[CSApply] Allow marker existential to superclass conversions

If existential is a protocol composition type where all of the protocols are `@_marker`, narrowly allow coercion to its superclass bound (if it matches). Both types have the same representation which makes it okay. This is only a problem in Swift 5 mode without strict concurrency checks. In this mode `@preconcurrency` stripping happens outside of the solver which means that no conversion restrictions are recorded for members that got `& Sendable` stripped from their types. For example: ```swift struct S { @preconcurrency static let member: KeyPath<String, Int> & Sendable } func test() { _ = S.member } ``` Since `member` is `@preconcurrency` its type would get concurrency annotations stripped, which includes `& Sendable` which means that the solver uses `KeyPath<String, Int>` type for the reference and not the original `KeyPath<String, Int> & Sendable`, this is a problem for `ExprRewritter::adjustTypeForDeclReference` because conversion between existential and its superclass bound requires a constraint restriction which won't be available in this case. Resolves: rdar://132700409

Author: xedin

lib/Sema/CSApply.cpp

@@ -7806,6 +7806,20 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
  llvm_unreachable("BuiltinTupleType should not show up here");
  }
 
+ // Allow existential-to-supertype conversion if all protocol
+ // bounds are marker protocols. Normally this requires a
+ // conversion restriction but there are situations related
+ // to `@preconcurrency` where the `& Sendable` would be stripped
+ // transparently to the solver.
+ if (auto *existential = fromType->getAs<ExistentialType>()) {
+ if (auto *PCT = existential->getConstraintType()
+ ->getAs<ProtocolCompositionType>()) {
+ if (PCT->withoutMarkerProtocols()->isEqual(toType)) {
+ return coerceSuperclass(expr, toType);
+ }
+ }
+ }
+
  // Unresolved types come up in diagnostics for lvalue and inout types.
  if (fromType->hasUnresolvedType() || toType->hasUnresolvedType())
  return cs.cacheType(new (ctx) UnresolvedTypeConversionExpr(expr, toType));

test/Concurrency/predates_concurrency.swift

@@ -302,3 +302,33 @@ do {
  }
  }
 }
+
+// rdar://132700409 - coercion PartialKeyPath & Sendable -> PartialKeyPath crashes in CSApply
+do {
+ struct Test {
+ enum KeyPath {
+ static var member: PartialKeyPath<Test> {
+ fatalError()
+ }
+ }
+ }
+
+ struct KeyPathComparator<Compared> {
+ @preconcurrency public let keyPath: any PartialKeyPath<Compared> & Sendable
+
+ func testDirect() {
+ switch keyPath { // Ok
+ case Test.KeyPath.member: break // Ok
+ default: break
+ }
+ }
+
+ func testErasure() {
+ let kp: PartialKeyPath<Compared> = keyPath
+ switch kp { // Ok
+ case Test.KeyPath.member: break // Ok
+ default: break
+ }
+ }
+ }
+}