Sema: improve function cast checking

Functions can in fact conform to some protocols, notably,
marker protocols. Dynamically they have no influence on whether the cast
will succeed or not, as there is no way to tell if a type conforms to
such a protocol at runtime. But we should check them statically because
they otherwise can be cast to Any eventually.

Author: kavon

lib/Sema/TypeCheckConstraints.cpp

@@ -1957,29 +1957,33 @@ TypeChecker::typeCheckCheckedCast(Type fromType, Type toType,
 
   // A cast from a function type to an existential type (except `Any`)
   // or an archetype type (with constraints) cannot succeed
-  auto toArchetypeType = toType->is<ArchetypeType>();
-  auto fromFunctionType = fromType->is<FunctionType>();
-  auto toExistentialType = toType->isAnyExistentialType();
-
-  auto toConstrainedArchetype = false;
-  if (toArchetypeType) {
-    auto archetype = toType->castTo<ArchetypeType>();
-    toConstrainedArchetype = !archetype->getConformsTo().empty();
-  }
-
-  if (fromFunctionType &&
-      (toExistentialType || (toArchetypeType && toConstrainedArchetype))) {
-    switch (contextKind) {
-    case CheckedCastContextKind::None:
-    case CheckedCastContextKind::ConditionalCast:
-    case CheckedCastContextKind::ForcedCast:
-      return CheckedCastKind::Unresolved;
+  if (fromType->is<FunctionType>()) {
+    auto toArchetypeType = toType->is<ArchetypeType>();
+    auto toExistentialType = toType->isAnyExistentialType();
+
+    auto conformsToAllProtocols = true;
+    if (toArchetypeType) {
+      auto archetype = toType->castTo<ArchetypeType>();
+      conformsToAllProtocols = llvm::all_of(archetype->getConformsTo(),
+        [&](ProtocolDecl *proto) {
+          return module->checkConformance(fromType, proto,
+                                          /*allowMissing=*/false);
+        });
+    }
 
-    case CheckedCastContextKind::IsPattern:
-    case CheckedCastContextKind::EnumElementPattern:
-    case CheckedCastContextKind::IsExpr:
-    case CheckedCastContextKind::Coercion:
-      break;
+    if (toExistentialType || (toArchetypeType && !conformsToAllProtocols)) {
+      switch (contextKind) {
+      case CheckedCastContextKind::None:
+      case CheckedCastContextKind::ConditionalCast:
+      case CheckedCastContextKind::ForcedCast:
+        return CheckedCastKind::Unresolved;
+
+      case CheckedCastContextKind::IsPattern:
+      case CheckedCastContextKind::EnumElementPattern:
+      case CheckedCastContextKind::IsExpr:
+      case CheckedCastContextKind::Coercion:
+        break;
+      }
     }
   }
 

test/Interpreter/casts.swift

@@ -142,3 +142,13 @@ Casts.test("testCastProtocolWithAnyObjectToProtocolCompoTypeSuperclass") {
   let shouldBeNil = (F() as QAny) as? KQAny
   expectNil(shouldBeNil)
 }
+
+func f1() -> Any { return 1 }
+func attemptFunctionCast<U>(_ u: U.Type) -> U? {
+  return f1 as? U
+}
+Casts.test("testFunctionCastToArchetype") {
+  expectNil(attemptFunctionCast(Int.self))
+  expectNil(attemptFunctionCast(K.self))
+  expectTrue(attemptFunctionCast(Any.self) != nil)
+}

test/expr/cast/as_coerce.swift

@@ -119,6 +119,7 @@ protocol P_48579 {}
 do {
   func f1() -> Any {}
   func f2() {}
+  @Sendable func f3() {}
 
   _ = f1 is P_48579 // expected-warning {{cast from '() -> Any' to unrelated type 'any P_48579' always fails}} // expected-note {{did you mean to call 'f1' with '()'?}}{{9-9=()}}
   _ = f1 as! P_48579 // expected-warning {{cast from '() -> Any' to unrelated type 'any P_48579' always fails}} // expected-note {{did you mean to call 'f1' with '()'?}}{{9-9=()}}
@@ -133,20 +134,32 @@ do {
   _ = f2 as? Any // expected-warning {{conditional cast from '() -> ()' to 'Any' always succeeds}}
 
 
-  func test1<T: P_48579>(_: T.Type) {
+  func test1<T: P_48579, V: P_48579 & Sendable>(_: T.Type, _: V.Type) {
     _ = f1 is T // expected-warning {{cast from '() -> Any' to unrelated type 'T' always fails}} // expected-note {{did you mean to call 'f1' with '()'?}}{{11-11=()}}
-    _ = f1 as! T // expected-warning {{cast from '() -> Any' to unrelated type 'T' always fails}} // expected-note {{did you mean to call 'f1' with '()'?}}{{11-11=()}}
+    _ = f1 as! V // expected-warning {{cast from '() -> Any' to unrelated type 'V' always fails}} // expected-note {{did you mean to call 'f1' with '()'?}}{{11-11=()}}
     _ = f1 as? T // expected-warning {{cast from '() -> Any' to unrelated type 'T' always fails}} // expected-note {{did you mean to call 'f1' with '()'?}}{{11-11=()}}
     _ = f2 is T // expected-warning {{cast from '() -> ()' to unrelated type 'T' always fails}}
-    _ = f2 as! T // expected-warning {{cast from '() -> ()' to unrelated type 'T' always fails}}
+    _ = f2 as! V // expected-warning {{cast from '() -> ()' to unrelated type 'V' always fails}}
     _ = f2 as? T // expected-warning {{cast from '() -> ()' to unrelated type 'T' always fails}}
+    _ = f3 is T // expected-warning {{cast from '@Sendable () -> ()' to unrelated type 'T' always fails}}
+    _ = f3 as! V // expected-warning {{cast from '@Sendable () -> ()' to unrelated type 'V' always fails}}
+    _ = f3 as? T // expected-warning {{cast from '@Sendable () -> ()' to unrelated type 'T' always fails}}
   }
 
-  func test2<U>(_: U.Type) {
+  func test2<U, S: Sendable>(_: U.Type, _: S.Type) {
+    _ = f1 is U  // Okay
     _ = f1 as! U // Okay
     _ = f1 as? U // Okay
+    _ = f1 is U  // Okay
     _ = f2 as! U // Okay
     _ = f2 as? U // Okay
+
+    _ = f2 is S   // expected-warning {{cast from '() -> ()' to unrelated type 'S' always fails}}
+    _ = f2 as! S  // expected-warning {{cast from '() -> ()' to unrelated type 'S' always fails}}
+    _ = f2 as? S  // expected-warning {{cast from '() -> ()' to unrelated type 'S' always fails}}
+    _ = f3 is S   // Okay
+    _ = f3 as! S  // Okay
+    _ = f3 as? S  // Okay
   }
 }