Introduce a function conversion for "adjusted" dynamic member references.

When we have adjusted the type of a dynamic member reference (e.g.,
for `@objc optional` methods) due to `@preconcurrency` or similar,
form the original dynamic member reference based on the original type
and then introduce an appropriate conversion. This better reflects the
adjustment in the AST, eliminating a SIL verifier crash.

Fixes rdar://94597323.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -896,6 +896,48 @@ namespace {
       return closedAny;
     }
 
+    /// When we have a reference to a declaration whose type in context is
+    /// different from its normal interface type, introduce the appropriate
+    /// conversions. This can happen due to `@preconcurrency`.
+    Expr *adjustTypeForDeclReference(
+        Expr *expr, Type openedType, Type adjustedOpenedType,
+        llvm::function_ref<Type(Type)> getNewType = [](Type type) {
+          return type;
+        }) {
+      // If the types are the same, do nothing.
+      if (openedType->isEqual(adjustedOpenedType))
+        return expr;
+
+      auto &context = cs.getASTContext();
+
+      // If we have an optional type, wrap it up in a monadic '?' and recurse.
+      if (Type objectType = openedType->getOptionalObjectType()) {
+        Type adjustedRefType = getNewType(adjustedOpenedType);
+        Type adjustedObjectType = adjustedRefType->getOptionalObjectType();
+        assert(adjustedObjectType && "Not an optional?");
+
+        expr = new (context) BindOptionalExpr(expr, SourceLoc(), 0, objectType);
+        cs.cacheType(expr);
+        expr = adjustTypeForDeclReference(expr, objectType, adjustedObjectType);
+        expr = new (context) InjectIntoOptionalExpr(expr, adjustedRefType);
+        cs.cacheType(expr);
+        expr = new (context) OptionalEvaluationExpr(expr, adjustedRefType);
+        cs.cacheType(expr);
+        return expr;
+      }
+
+      // For a function type, perform a function conversion.
+      if (openedType->is<AnyFunctionType>()) {
+        expr = new (context) FunctionConversionExpr(
+            expr, getNewType(adjustedOpenedType));
+        cs.cacheType(expr);
+        return expr;
+      }
+
+      assert(false && "Unhandled adjustment");
+      return expr;
+    }
+
     /// Determines if a partially-applied member reference should be
     /// converted into a fully-applied member reference with a pair of
     /// closures.
@@ -1388,6 +1430,7 @@ namespace {
                          ConstraintLocatorBuilder memberLocator, bool Implicit,
                          AccessSemantics semantics) {
       const auto &choice = overload.choice;
+      const auto openedType = overload.openedType;
       const auto adjustedOpenedType = overload.adjustedOpenedType;
 
       ValueDecl *member = choice.getDecl();
@@ -1597,7 +1640,7 @@ namespace {
 
         auto computeRefType = [&](Type openedType) {
           // Compute the type of the reference.
-          Type refType = simplifyType(adjustedOpenedType);
+          Type refType = simplifyType(openedType);
 
           // If the base was an opened existential, erase the opened
           // existential.
@@ -1609,9 +1652,13 @@ namespace {
           return refType;
         };
 
-        Type refType = computeRefType(adjustedOpenedType);
+        Type refType = computeRefType(openedType);
         cs.setType(ref, refType);
 
+        // Adjust the declaration reference type, if required.
+        ref = adjustTypeForDeclReference(
+            ref, openedType, adjustedOpenedType, computeRefType);
+
         closeExistentials(ref, locator, /*force=*/openedExistential);
 
         // We also need to handle the implicitly unwrap of the result

test/SILGen/objc_preconcurrency.swift

@@ -0,0 +1,14 @@
+// RUN: %target-swift-emit-silgen -module-name objc_preconcurrency -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+@objc protocol P {
+  @preconcurrency @objc optional func f(_ completionHandler: @Sendable @escaping () -> Void)
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s19objc_preconcurrency19testDynamicDispatch1p17completionHandleryAA1P_p_yyctF
+// CHECK: dynamic_method_br
+// CHECK: bb{{[0-9]+}}(%{{[0-9]+}} : $@convention(objc_method) (@convention(block) @Sendable () -> (), @opened
+func testDynamicDispatch(p: P, completionHandler: @escaping () -> Void) {
+  p.f?(completionHandler)
+}