[region-isolation] Codegen unsafe continuation result using calls to foreign APIs in the same manner as with checked continuation.

gottesmm · gottesmm · commit dddfdc891ffa · 2024-11-01T11:25:17.000-07:00
The reason why I am doing this is that the unlike the codegen for checked continuation, the codegen for unchecked continuation uses a sendable value instead of Any as the block storage which prevents me from being able to create a dependency from a non-Sendable @out parameter to the block. By changing to use Any consistently, we are able to take advantage of Any not being sendable to properly propagate this information.
diff --git a/lib/SILGen/ResultPlan.cpp b/lib/SILGen/ResultPlan.cpp
@@ -752,34 +752,29 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
               ->getCanonicalType();
     }
 
-    auto blockStorageTy = SILBlockStorageType::get(
-        checkedBridging ? ctx.TheAnyType : continuationTy);
+    auto blockStorageTy = SILBlockStorageType::get(ctx.TheAnyType);
     auto blockStorage = SGF.emitTemporaryAllocation(
         loc, SILType::getPrimitiveAddressType(blockStorageTy));
 
     auto continuationAddr = SGF.B.createProjectBlockStorage(loc, blockStorage);
 
     // Stash continuation in a buffer for a block object.
+    auto conformances =
+        collectExistentialConformances(continuationTy, ctx.TheAnyType);
+
+    // In this case block storage captures `Any` which would be initialized
+    // with a continuation.
+    auto underlyingContinuationAddr = SGF.B.createInitExistentialAddr(
+        loc, continuationAddr, continuationTy,
+        SGF.getLoweredType(continuationTy), conformances);
 
     if (checkedBridging) {
       auto createIntrinsic =
           throws ? SGF.SGM.getCreateCheckedThrowingContinuation()
                  : SGF.SGM.getCreateCheckedContinuation();
-
-      auto conformances = collectExistentialConformances(
-          continuationTy, ctx.TheAnyType);
-
-      // In this case block storage captures `Any` which would be initialized
-      // with an checked continuation.
-      auto underlyingContinuationAddr =
-          SGF.B.createInitExistentialAddr(loc, continuationAddr, continuationTy,
-                                          SGF.getLoweredType(continuationTy),
-                                          conformances);
-
-      auto subs = SubstitutionMap::get(createIntrinsic->getGenericSignature(),
-                                       {calleeTypeInfo.substResultType},
-                                       conformances);
-
+      auto subs =
+          SubstitutionMap::get(createIntrinsic->getGenericSignature(),
+                               {calleeTypeInfo.substResultType}, conformances);
       InitializationPtr underlyingInit(
           new KnownAddressInitialization(underlyingContinuationAddr));
       auto continuationMV =
@@ -788,7 +783,7 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
                                       {continuationMV}, SGFContext())
           .forwardInto(SGF, loc, underlyingInit.get());
     } else {
-      SGF.B.createStore(loc, wrappedContinuation, continuationAddr,
+      SGF.B.createStore(loc, wrappedContinuation, underlyingContinuationAddr,
                         StoreOwnershipQualifier::Trivial);
     }
 
@@ -917,7 +912,7 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
             SGF.B.createProjectBlockStorage(loc, blockStorage);
 
         ManagedValue continuation;
-        if (checkedBridging) {
+        {
           FormalEvaluationScope scope(SGF);
 
           auto underlyingValueTy =
@@ -930,11 +925,11 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
           continuation = SGF.B.createUncheckedAddrCast(
               loc, underlyingValueAddr,
               SILType::getPrimitiveAddressType(continuationTy));
-        } else {
-          auto continuationVal = SGF.B.createLoad(
-              loc, continuationAddr, LoadOwnershipQualifier::Trivial);
-          continuation =
-              ManagedValue::forObjectRValueWithoutOwnership(continuationVal);
+
+          // If we are calling the unsafe variant, we always pass the value in
+          // registers.
+          if (!checkedBridging)
+            continuation = SGF.B.createLoadTrivial(loc, continuation);
         }
 
         auto mappedOutContinuationTy =
diff --git a/lib/SILGen/SILGenThunk.cpp b/lib/SILGen/SILGenThunk.cpp
@@ -380,7 +380,7 @@ SILFunction *SILGenModule::getOrCreateForeignAsyncCompletionHandlerImplFunction(
       bool checkedBridging = ctx.LangOpts.UseCheckedAsyncObjCBridging;
 
       ManagedValue continuation;
-      if (checkedBridging) {
+      {
         FormalEvaluationScope scope(SGF);
 
         auto underlyingValueTy = OpenedArchetypeType::get(ctx.TheAnyType);
@@ -393,11 +393,12 @@ SILFunction *SILGenModule::getOrCreateForeignAsyncCompletionHandlerImplFunction(
             loc, underlyingValueAddr,
             SILType::getPrimitiveAddressType(
                 F->mapTypeIntoContext(continuationType)->getCanonicalType()));
-      } else {
-        auto continuationVal = SGF.B.createLoad(
-            loc, continuationAddr, LoadOwnershipQualifier::Trivial);
-        continuation =
-            ManagedValue::forObjectRValueWithoutOwnership(continuationVal);
+
+        // If we are not using checked bridging, we load the continuation from
+        // memory since we are going to pass it in registers, not in memory to
+        // the intrinsic.
+        if (!checkedBridging)
+          continuation = SGF.B.createLoadTrivial(loc, continuation);
       }
 
       // Check for an error if the convention includes one.
diff --git a/test/SILGen/objc_async.swift b/test/SILGen/objc_async.swift
@@ -13,10 +13,11 @@ func testSlowServer(slowServer: SlowServer) async throws {
   // CHECK: [[METHOD:%.*]] = objc_method {{.*}} $@convention(objc_method) (NSString, @convention(block) (Int) -> (), SlowServer) -> ()
   // CHECK: [[CONT:%.*]] = get_async_continuation_addr Int, [[RESUME_BUF]]
   // CHECK: [[WRAPPED:%.*]] = struct $UnsafeContinuation<Int, Never> ([[CONT]] : $Builtin.RawUnsafeContinuation)
-  // CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage UnsafeContinuation<Int, Never>
+  // CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage Any
   // CHECK: [[CONT_SLOT:%.*]] = project_block_storage [[BLOCK_STORAGE]]
-  // CHECK: store [[WRAPPED]] to [trivial] [[CONT_SLOT]]
-  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[INT_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<Int, Never>, Int) -> ()
+  // CHECK: [[CONT_SLOT_ADDR:%.*]] = init_existential_addr [[CONT_SLOT]]
+  // CHECK: store [[WRAPPED]] to [trivial] [[CONT_SLOT_ADDR]]
+  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[INT_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any, Int) -> ()
   // CHECK: [[BLOCK:%.*]] = init_block_storage_header [[BLOCK_STORAGE]] {{.*}}, invoke [[BLOCK_IMPL]]
   // CHECK: apply [[METHOD]]([[ARG]], [[BLOCK]], %0)
   // CHECK: [[COPY:%.*]] = copy_value [[ARG]]
@@ -35,10 +36,11 @@ func testSlowServer(slowServer: SlowServer) async throws {
   // CHECK: [[METHOD:%.*]] = objc_method {{.*}} $@convention(objc_method) (@convention(block) (Optional<NSString>, Optional<NSError>) -> (), SlowServer) -> ()
   // CHECK: [[CONT:%.*]] = get_async_continuation_addr [throws] String, [[RESUME_BUF]]
   // CHECK: [[WRAPPED:%.*]] = struct $UnsafeContinuation<String, any Error> ([[CONT]] : $Builtin.RawUnsafeContinuation)
-  // CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage UnsafeContinuation<String, any Error>
+  // CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage Any
   // CHECK: [[CONT_SLOT:%.*]] = project_block_storage [[BLOCK_STORAGE]]
-  // CHECK: store [[WRAPPED]] to [trivial] [[CONT_SLOT]]
-  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[STRING_COMPLETION_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<String, any Error>, Optional<NSString>, Optional<NSError>) -> ()
+  // CHECK: [[CONT_SLOT_ADDR:%.*]] = init_existential_addr [[CONT_SLOT]]
+  // CHECK: store [[WRAPPED]] to [trivial] [[CONT_SLOT_ADDR]]
+  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[STRING_COMPLETION_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any, Optional<NSString>, Optional<NSError>) -> ()
   // CHECK: [[BLOCK:%.*]] = init_block_storage_header [[BLOCK_STORAGE]] {{.*}}, invoke [[BLOCK_IMPL]]
   // CHECK: apply [[METHOD]]([[BLOCK]], %0)
   // CHECK: await_async_continuation [[CONT]] {{.*}}, resume [[RESUME:bb[0-9]+]], error [[ERROR:bb[0-9]+]]
@@ -49,17 +51,17 @@ func testSlowServer(slowServer: SlowServer) async throws {
   let _: String = try await slowServer.findAnswer()
 
   // CHECK: objc_method {{.*}} $@convention(objc_method) (NSString, @convention(block) () -> (), SlowServer) -> ()
-  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[VOID_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<(), Never>) -> ()
+  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[VOID_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any) -> ()
   await slowServer.serverRestart("somewhere")
 
-  // CHECK: function_ref @[[STRING_NONZERO_FLAG_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<String, any Error>, {{.*}}Bool, Optional<NSString>, Optional<NSError>) -> ()
+  // CHECK: function_ref @[[STRING_NONZERO_FLAG_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any, {{.*}}Bool, Optional<NSString>, Optional<NSError>) -> ()
   let _: String = try await slowServer.doSomethingFlaggy()
-  // CHECK: function_ref @[[STRING_ZERO_FLAG_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<String, any Error>, Optional<NSString>, {{.*}}Bool, Optional<NSError>) -> ()
+  // CHECK: function_ref @[[STRING_ZERO_FLAG_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any, Optional<NSString>, {{.*}}Bool, Optional<NSError>) -> ()
   let _: String = try await slowServer.doSomethingZeroFlaggy()
-  // CHECK: function_ref @[[STRING_STRING_ZERO_FLAG_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<(String, String), any Error>, {{.*}}Bool, Optional<NSString>, Optional<NSError>, Optional<NSString>) -> ()
+  // CHECK: function_ref @[[STRING_STRING_ZERO_FLAG_THROW_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any, {{.*}}Bool, Optional<NSString>, Optional<NSError>, Optional<NSString>) -> ()
   let _: (String, String) = try await slowServer.doSomethingMultiResultFlaggy()
 
-  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[NSSTRING_INT_THROW_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<(String, Int), any Error>, Optional<NSString>, Int, Optional<NSError>) -> ()
+  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[NSSTRING_INT_THROW_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any, Optional<NSString>, Int, Optional<NSError>) -> ()
   let (_, _): (String, Int) = try await slowServer.findMultipleAnswers()
 
   let (_, _): (Bool, Bool) = try await slowServer.findDifferentlyFlavoredBooleans()
@@ -103,7 +105,9 @@ func testGeneric2<T: AnyObject, U>(x: GenericObject<T>, y: U) async throws {
 
 // CHECK: sil{{.*}}@[[INT_COMPLETION_BLOCK]]
 // CHECK:   [[CONT_ADDR:%.*]] = project_block_storage %0
-// CHECK:   [[CONT:%.*]] = load [trivial] [[CONT_ADDR]]
+// CHECK:   [[CONT_OPEN_EXT:%.*]] = open_existential_addr immutable_access [[CONT_ADDR]]
+// CHECK:   [[CONT_CAST:%.*]] = unchecked_addr_cast [[CONT_OPEN_EXT]]
+// CHECK:   [[CONT:%.*]] = load [trivial] [[CONT_CAST]]
 // CHECK:   [[RESULT_BUF:%.*]] = alloc_stack $Int
 // CHECK:   store %1 to [trivial] [[RESULT_BUF]]
 // CHECK:   [[RESUME:%.*]] = function_ref @{{.*}}resumeUnsafeContinuation
@@ -113,7 +117,9 @@ func testGeneric2<T: AnyObject, U>(x: GenericObject<T>, y: U) async throws {
 // CHECK:   [[RESUME_IN:%.*]] = copy_value %1
 // CHECK:   [[ERROR_IN:%.*]] = copy_value %2
 // CHECK:   [[CONT_ADDR:%.*]] = project_block_storage %0
-// CHECK:   [[CONT:%.*]] = load [trivial] [[CONT_ADDR]]
+// CHECK:   [[CONT_ADDR_OPENED:%.*]] = open_existential_addr immutable_access [[CONT_ADDR]]
+// CHECK:   [[CONT_ADDR_CAST:%.*]] = unchecked_addr_cast [[CONT_ADDR_OPENED]]
+// CHECK:   [[CONT:%.*]] = load [trivial] [[CONT_ADDR_CAST]]
 // CHECK:   [[ERROR_IN_B:%.*]] = begin_borrow [[ERROR_IN]]
 // CHECK:   switch_enum [[ERROR_IN_B]] : {{.*}}, case #Optional.some!enumelt: [[ERROR_BB:bb[0-9]+]], case #Optional.none!enumelt: [[RESUME_BB:bb[0-9]+]]
 // CHECK: [[RESUME_BB]]:
@@ -136,7 +142,9 @@ func testGeneric2<T: AnyObject, U>(x: GenericObject<T>, y: U) async throws {
 
 // CHECK: sil {{.*}} @[[VOID_COMPLETION_BLOCK]]
 // CHECK:   [[CONT_ADDR:%.*]] = project_block_storage %0
-// CHECK:   [[CONT:%.*]] = load [trivial] [[CONT_ADDR]]
+// CHECK:   [[CONT_OPEN:%.*]] = open_existential_addr immutable_access [[CONT_ADDR]]
+// CHECK:   [[CONT_CAST:%.*]] = unchecked_addr_cast [[CONT_OPEN]]
+// CHECK:   [[CONT:%.*]] = load [trivial] [[CONT_CAST]]
 // CHECK:   [[RESULT_BUF:%.*]] = alloc_stack $()
 // CHECK:   [[RESUME:%.*]] = function_ref @{{.*}}resumeUnsafeContinuation
 // CHECK:   apply [[RESUME]]<()>([[CONT]], [[RESULT_BUF]])
@@ -184,10 +192,11 @@ func testSlowServerFromMain(slowServer: SlowServer) async throws {
   // CHECK: [[METHOD:%.*]] = objc_method {{.*}} $@convention(objc_method) (NSString, @convention(block) (Int) -> (), SlowServer) -> ()
   // CHECK: [[CONT:%.*]] = get_async_continuation_addr Int, [[RESUME_BUF]]
   // CHECK: [[WRAPPED:%.*]] = struct $UnsafeContinuation<Int, Never> ([[CONT]] : $Builtin.RawUnsafeContinuation)
-  // CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage UnsafeContinuation<Int, Never>
+  // CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage Any
   // CHECK: [[CONT_SLOT:%.*]] = project_block_storage [[BLOCK_STORAGE]]
-  // CHECK: store [[WRAPPED]] to [trivial] [[CONT_SLOT]]
-  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[INT_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage UnsafeContinuation<Int, Never>, Int) -> ()
+  // CHECK: [[CONT_SLOT_ANY:%.*]] = init_existential_addr [[CONT_SLOT]]
+  // CHECK: store [[WRAPPED]] to [trivial] [[CONT_SLOT_ANY]]
+  // CHECK: [[BLOCK_IMPL:%.*]] = function_ref @[[INT_COMPLETION_BLOCK:.*]] : $@convention(c) (@inout_aliasable @block_storage Any, Int) -> ()
   // CHECK: [[BLOCK:%.*]] = init_block_storage_header [[BLOCK_STORAGE]] {{.*}}, invoke [[BLOCK_IMPL]]
   // CHECK: apply [[METHOD]]([[ARG]], [[BLOCK]], %0)
   // CHECK: [[COPY:%.*]] = copy_value [[ARG]]
@@ -210,15 +219,16 @@ func testThrowingMethodFromMain(slowServer: SlowServer) async -> String {
 // CHECK:  [[METH:%.*]] = objc_method {{%.*}} : $SlowServer, #SlowServer.doSomethingDangerous!foreign
 // CHECK:  [[RAW_CONT:%.*]] = get_async_continuation_addr [throws] String, [[RESULT_BUF]] : $*String
 // CHECK:  [[CONT:%.*]] = struct $UnsafeContinuation<String, any Error> ([[RAW_CONT]] : $Builtin.RawUnsafeContinuation)
-// CHECK:  [[STORE_ALLOC:%.*]] = alloc_stack $@block_storage UnsafeContinuation<String, any Error>
+// CHECK:  [[STORE_ALLOC:%.*]] = alloc_stack $@block_storage Any
 // CHECK:  [[PROJECTED:%.*]] = project_block_storage [[STORE_ALLOC]] : $*@block_storage
-// CHECK:  store [[CONT]] to [trivial] [[PROJECTED]] : $*UnsafeContinuation<String, any Error>
+// CHECK:  [[PROJECTED_ANY:%.*]] = init_existential_addr [[PROJECTED]]
+// CHECK:  store [[CONT]] to [trivial] [[PROJECTED_ANY]]
 // CHECK:  [[INVOKER:%.*]] = function_ref @$sSo8NSStringCSgSo7NSErrorCSgIeyByy_SSTz_
 // CHECK:  [[BLOCK:%.*]] = init_block_storage_header [[STORE_ALLOC]] {{.*}}, invoke [[INVOKER]]
 // CHECK:  [[OPTIONAL_BLK:%.*]] = enum {{.*}}, #Optional.some!enumelt, [[BLOCK]]
-// CHECK:  %28 = apply [[METH]]([[STRING_ARG]], [[OPTIONAL_BLK]], {{%.*}}) : $@convention(objc_method) (NSString, Optional<@convention(block) (Optional<NSString>, Optional<NSError>) -> ()>, SlowServer) -> ()
+// CHECK:  apply [[METH]]([[STRING_ARG]], [[OPTIONAL_BLK]], {{%.*}}) : $@convention(objc_method) (NSString, Optional<@convention(block) (Optional<NSString>, Optional<NSError>) -> ()>, SlowServer) -> ()
 // CHECK:  [[STRING_ARG_COPY:%.*]] = copy_value [[STRING_ARG]] : $NSString
-// CHECK:  dealloc_stack [[STORE_ALLOC]] : $*@block_storage UnsafeContinuation<String, any Error>
+// CHECK:  dealloc_stack [[STORE_ALLOC]] : $*@block_storage Any
 // CHECK:  destroy_value [[STRING_ARG]] : $NSString
 // CHECK:  await_async_continuation [[RAW_CONT]] : $Builtin.RawUnsafeContinuation, resume [[RESUME:bb[0-9]+]], error [[ERROR:bb[0-9]+]]
 
@@ -288,11 +298,12 @@ extension OptionalMemberLookups {
   // CHECK:         [[SELF:%[0-9]+]] = copy_value {{.*}} : $Self
   // CHECK:         [[METH:%[0-9]+]] = objc_method {{.*}} : $Self, #OptionalMemberLookups.generateMaybe!foreign : <Self where Self : OptionalMemberLookups> (Self) -> () async -> (), $@convention(objc_method) (@convention(block) () -> (), Self) -> ()
   // CHECK:         [[CONT:%.*]] = struct $UnsafeContinuation<(), Never> (%10 : $Builtin.RawUnsafeContinuation)
-  // CHECK:         [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage UnsafeContinuation<(), Never>
-  // CHECK:         [[PROJECTED:%.*]] = project_block_storage [[BLOCK_STORAGE]] : $*@block_storage UnsafeContinuation<(), Never>
-  // CHECK:         store [[CONT]] to [trivial] [[PROJECTED]] : $*UnsafeContinuation<(), Never>
-  // CHECK:         = function_ref @$sIeyB_yt10objc_async21OptionalMemberLookupsRzlTz_ : $@convention(c) @pseudogeneric <τ_0_0 where τ_0_0 : OptionalMemberLookups> (@inout_aliasable @block_storage UnsafeContinuation<(), Never>) -> ()
-  // CHECK:         [[BLOCK:%[0-9]+]] = init_block_storage_header {{.*}} : $*@block_storage UnsafeContinuation<(), Never>
+  // CHECK:         [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage
+  // CHECK:         [[PROJECTED:%.*]] = project_block_storage [[BLOCK_STORAGE]] : $*@block_storage
+  // CHECK:         [[PROJECTED_ANY:%.*]] = init_existential_addr [[PROJECTED]]
+  // CHECK:         store [[CONT]] to [trivial] [[PROJECTED_ANY]]
+  // CHECK:         = function_ref @$sIeyB_yt10objc_async21OptionalMemberLookupsRzlTz_ : $@convention(c) @pseudogeneric <τ_0_0 where τ_0_0 : OptionalMemberLookups> (@inout_aliasable @block_storage Any) -> ()
+  // CHECK:         [[BLOCK:%[0-9]+]] = init_block_storage_header {{.*}} : $*@block_storage
   // CHECK:         = apply [[METH]]([[BLOCK]], [[SELF]]) : $@convention(objc_method) (@convention(block) () -> (), Self) -> ()
   // CHECK:         await_async_continuation {{.*}} : $Builtin.RawUnsafeContinuation, resume bb1
   // CHECK:         hop_to_executor {{.*}} : $MainActor
diff --git a/test/SILGen/objc_effectful_properties.swift b/test/SILGen/objc_effectful_properties.swift
