Look at whether the result is returned indirectly

Remove assertion that is no longer true.

Author: ahatanaka

lib/SILGen/SILGenBridging.cpp

@@ -1331,8 +1331,8 @@ static SILFunctionType *
 emitObjCThunkArguments(SILGenFunction &SGF, SILLocation loc, SILDeclRef thunk,
                        SmallVectorImpl<SILValue> &args,
                        SILValue &foreignErrorSlot, SILValue &foreignAsyncSlot,
-                       std::optional<ForeignErrorConvention> &foreignError,
-                       std::optional<ForeignAsyncConvention> &foreignAsync,
+                       std::optional<ForeignErrorConvention> foreignError,
+                       std::optional<ForeignAsyncConvention> foreignAsync,
                        CanType &nativeFormalResultTy,
                        CanType &bridgedFormalResultTy) {
   SILDeclRef native = thunk.asForeign(false);
@@ -1355,20 +1355,6 @@ emitObjCThunkArguments(SILGenFunction &SGF, SILLocation loc, SILDeclRef thunk,
   SmallVector<ManagedValue, 8> bridgedArgs;
   bridgedArgs.reserve(objcFnTy->getParameters().size());
 
-  // Find the foreign error and async conventions if we have one.
-  if (thunk.hasDecl()) {
-    if (auto func = dyn_cast<AbstractFunctionDecl>(thunk.getDecl())) {
-      foreignError = func->getForeignErrorConvention();
-      foreignAsync = func->getForeignAsyncConvention();
-    }
-  }
-
-  // We don't know what to do with indirect results from the Objective-C side.
-  assert((SGF.F.getRepresentation() ==
-              SILFunctionType::Representation::CFunctionPointer ||
-          objcFnTy->getNumIndirectFormalResults() == 0) &&
-         "Objective-C methods cannot have indirect results");
-
   auto bridgedFormalTypes = getParameterTypes(objcFormalFnTy.getParams());
   bridgedFormalResultTy = objcFormalFnTy.getResult();
 
@@ -1618,27 +1604,40 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
     }
   }
 
+  std::optional<ForeignErrorConvention> foreignError;
+  std::optional<ForeignAsyncConvention> foreignAsync;
+
+  // Find the foreign error and async conventions if we have one.
+  if (thunk.hasDecl()) {
+    if (auto func = dyn_cast<AbstractFunctionDecl>(thunk.getDecl())) {
+      foreignError = func->getForeignErrorConvention();
+      foreignAsync = func->getForeignAsyncConvention();
+    }
+  }
+
+  // If we are bridging a Swift method with Any return value(s), create a
+  // stack allocation to hold the result(s), since Any is address-only.
   SmallVector<SILValue, 4> args;
+  SILFunctionConventions funcConv = F.getConventions();
+  bool needsBridging = true;
   if (substConv.hasIndirectSILResults()) {
-    if (F.getRepresentation() ==
-        SILFunctionType::Representation::CFunctionPointer) {
-      // Pass the result address of the thunk to the native function.
-      auto resultTy =
-          F.getConventions().getSingleSILResultType(getTypeExpansionContext());
-      assert(resultTy ==
-                 substConv.getSingleSILResultType(getTypeExpansionContext()) &&
-             "result type mismatch");
-      args.push_back(F.begin()->createFunctionArgument(resultTy));
-    } else {
-      // If we are bridging a Swift method with Any return value(s), create a
-      // stack allocation to hold the result(s), since Any is address-only.
-      for (auto result : substConv.getResults()) {
-        if (!substConv.isSILIndirect(result)) {
-          continue;
-        }
-        args.push_back(emitTemporaryAllocation(
-            loc, substConv.getSILType(result, getTypeExpansionContext())));
+    for (auto result : substConv.getResults()) {
+      if (!substConv.isSILIndirect(result)) {
+        continue;
+      }
+
+      if (!foreignAsync && funcConv.hasIndirectSILResults()) {
+        auto resultTy =
+            funcConv.getSingleSILResultType(getTypeExpansionContext());
+        assert(substConv.getSingleSILResultType(getTypeExpansionContext()) ==
+               resultTy);
+        args.push_back(F.begin()->createFunctionArgument(resultTy));
+        needsBridging = false;
+        break;
       }
+
+      args.push_back(emitTemporaryAllocation(
+          loc, substConv.getSILType(result, getTypeExpansionContext())));
     }
   }
 
@@ -1648,8 +1647,6 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   Scope argScope(Cleanups, CleanupLocation(loc));
 
   // Bridge the arguments.
-  std::optional<ForeignErrorConvention> foreignError;
-  std::optional<ForeignAsyncConvention> foreignAsync;
   SILValue foreignErrorSlot;
   SILValue foreignAsyncSlot;
   CanType nativeFormalResultType, bridgedFormalResultType;
@@ -1876,7 +1873,7 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
     if (foreignAsync) {
       result = passResultToCompletionHandler(result);
     } else {
-      if (F.getRepresentation() != SILFunctionType::Representation::CFunctionPointer) {
+      if (needsBridging) {
         if (substConv.hasIndirectSILResults()) {
           assert(substTy->getNumResults() == 1);
           result = args[0];