SILGen: Handle _Nullable completion handler arguments to imported async APIs.

Author: jckarter

lib/SILGen/ResultPlan.cpp

@@ -511,18 +511,33 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
     // Get the block invocation function for the given completion block type.
     auto completionHandlerIndex = calleeTypeInfo.foreign.async
       ->completionHandlerParamIndex();
-    auto implTy = cast<SILFunctionType>(calleeTypeInfo.substFnType
-      ->getParameters()[completionHandlerIndex]
-      .getInterfaceType());
+    auto impTy = SGF.getSILType(calleeTypeInfo.substFnType
+                                      ->getParameters()[completionHandlerIndex],
+                                calleeTypeInfo.substFnType);
+    bool handlerIsOptional;
+    CanSILFunctionType impFnTy;
+    if (auto impObjTy = impTy.getOptionalObjectType()) {
+      handlerIsOptional = true;
+      impFnTy = cast<SILFunctionType>(impObjTy.getASTType());
+    } else {
+      handlerIsOptional = false;
+      impFnTy = cast<SILFunctionType>(impTy.getASTType());
+    }
     SILFunction *impl = SGF.SGM
-      .getOrCreateForeignAsyncCompletionHandlerImplFunction(implTy,
+      .getOrCreateForeignAsyncCompletionHandlerImplFunction(impFnTy,
                                                 continuationTy,
                                                 *calleeTypeInfo.foreign.async);
-    auto implRef = SGF.B.createFunctionRef(loc, impl);
+    auto impRef = SGF.B.createFunctionRef(loc, impl);
 
     // Initialize the block object for the completion handler.
-    auto block = SGF.B.createInitBlockStorageHeader(loc, blockStorage, implRef,
-                                  SILType::getPrimitiveObjectType(implTy), {});
+    SILValue block = SGF.B.createInitBlockStorageHeader(loc, blockStorage,
+                          impRef, SILType::getPrimitiveObjectType(impFnTy), {});
+    
+    // Wrap it in optional if the callee expects if.
+    if (handlerIsOptional) {
+      block = SGF.B.createOptionalSome(loc, block, impTy);
+    }
+    
     // We don't need to manage the block because it's still on the stack. We
     // know we won't escape it locally so the callee can be responsible for
     // _Block_copy-ing it.

test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h

@@ -44,6 +44,7 @@ typedef void (^CompletionHandler)(NSString * _Nullable, NSString * _Nullable_res
 
 -(void)repeatTrick:(NSString *)trick completionHandler:(void (^)(NSInteger))handler __attribute__((swift_async(none)));
 
+-(void)doSomethingSlowNullably:(NSString *)operation completionHandler:(void (^ _Nullable)(NSInteger))handler;
 @end
 
 @protocol RefrigeratorDelegate<NSObject>

test/SILGen/objc_async.swift

@@ -22,6 +22,8 @@ func testSlowServer(slowServer: SlowServer) async throws {
   // CHECK: dealloc_stack [[RESUME_BUF]]
   let _: Int = await slowServer.doSomethingSlow("mail")
 
+  let _: Int = await slowServer.doSomethingSlowNullably("mail")
+
   // CHECK: [[RESUME_BUF:%.*]] = alloc_stack $String
   // CHECK: [[METHOD:%.*]] = objc_method {{.*}} $@convention(objc_method) (@convention(block) (Optional<NSString>, Optional<NSError>) -> (), SlowServer) -> ()
   // CHECK: [[CONT:%.*]] = get_async_continuation_addr [throws] String, [[RESUME_BUF]]