Look through @Sendable conversions when considering C function pointer conversions.

Adding (or removing) `@Sendable` doesn't add context, so it shouldn't prevent
conversion to a C function pointer. Fix for rdar://127521718.

Author: jckarter

lib/SILGen/SILGenExpr.cpp

@@ -1778,6 +1778,19 @@ ManagedValue emitCFunctionPointer(SILGenFunction &SGF,
     loc = declRef.getDecl();
   };
 
+  if (auto conv = dyn_cast<FunctionConversionExpr>(semanticExpr)) {
+    // There might be an intermediate conversion adding or removing @Sendable.
+#ifndef NDEBUG
+    {
+      auto ty1 = conv->getType()->castTo<AnyFunctionType>();
+      auto ty2 = conv->getSubExpr()->getType()->castTo<AnyFunctionType>();
+      assert(ty1->withExtInfo(ty1->getExtInfo().withSendable(false))
+             ->isEqual(ty2->withExtInfo(ty2->getExtInfo().withSendable(false))));
+    }
+#endif
+    semanticExpr = conv->getSubExpr()->getSemanticsProvidingExpr();
+  }
+  
   if (auto declRef = dyn_cast<DeclRefExpr>(semanticExpr)) {
     setLocFromConcreteDeclRef(declRef->getDeclRef());
   } else if (auto memberRef = dyn_cast<MemberRefExpr>(semanticExpr)) {

lib/Sema/CSApply.cpp

@@ -6418,6 +6418,17 @@ maybeDiagnoseUnsupportedFunctionConversion(ConstraintSystem &cs, Expr *expr,
       }
     };
 
+    // Look through a function conversion that only adds or removes
+    // `@Sendable`.
+    if (auto conv = dyn_cast<FunctionConversionExpr>(semanticExpr)) {
+      auto ty1 = conv->getType()->castTo<AnyFunctionType>();
+      auto ty2 = conv->getSubExpr()->getType()->castTo<AnyFunctionType>();
+      if (ty1->withExtInfo(ty1->getExtInfo().withSendable(false))
+             ->isEqual(ty2->withExtInfo(ty2->getExtInfo().withSendable(false)))){
+        semanticExpr = conv->getSubExpr()->getSemanticsProvidingExpr();
+      }
+    }
+    
     if (auto declRef = dyn_cast<DeclRefExpr>(semanticExpr)) {
       if (auto fn = dyn_cast<FuncDecl>(declRef->getDecl())) {
         return maybeDiagnoseFunctionRef(fn);

test/SILGen/sendable_c_function_pointer_conversion.swift

@@ -0,0 +1,23 @@
+// RUN: %target-swift-emit-silgen -swift-version 5 -verify %s
+
+// In Swift 6 mode, we introduce an implicit `@Sendable` conversion on the
+// function value. Ensure that this doesn't impede C function pointer
+// conversion.
+// RUN: %target-swift-emit-silgen -swift-version 6 -verify %s
+
+public typealias PDCallbackFunction = @convention(c) (UnsafeMutableRawPointer?) -> Int32
+
+public enum System {
+  public static func setUpdateCallback(update: @escaping PDCallbackFunction, userdata: UnsafeMutableRawPointer?) {
+  }
+}
+
+@_cdecl("eventHandler")
+public func eventHandler(
+  pointer: UnsafeMutableRawPointer!
+) -> Int32 {
+  System.setUpdateCallback(update: update(pointer:), userdata: nil)
+  return 0
+}
+
+func update(pointer: UnsafeMutableRawPointer!) -> Int32 { 0 }