Merge pull request #75150 from drexin/wip-130971168

[IRGen] Don't apply direct error return to functions with indirect result

Author: drexin

lib/IRGen/GenCall.cpp

@@ -650,7 +650,7 @@ void SignatureExpansion::expandResult(
   const TypeInfo *directResultTypeInfo;
   std::tie(ResultIRType, directResultTypeInfo) = expandDirectResult();
 
-  if (!fnConv.hasIndirectSILErrorResults()) {
+  if (!fnConv.hasIndirectSILResults() && !fnConv.hasIndirectSILErrorResults()) {
     llvm::Type *directErrorType;
     const TypeInfo *directErrorTypeInfo;
     std::tie(directErrorType, directErrorTypeInfo) = expandDirectErrorType();
@@ -2032,7 +2032,8 @@ void SignatureExpansion::expandParameters(
       auto &errorTI = IGM.getTypeInfo(errorType);
       auto &nativeError = errorTI.nativeReturnValueSchema(IGM);
 
-      if (getSILFuncConventions().hasIndirectSILErrorResults() ||
+      if (getSILFuncConventions().hasIndirectSILResults() ||
+          getSILFuncConventions().hasIndirectSILErrorResults() ||
           native.requiresIndirect() ||
           nativeError.shouldReturnTypedErrorIndirectly()) {
         ParamIRTypes.push_back(IGM.getStorageType(errorType)->getPointerTo());
@@ -2595,7 +2596,8 @@ class SyncCallEmission final : public CallEmission {
           auto &errorSchema =
               IGF.IGM.getTypeInfo(silErrorTy).nativeReturnValueSchema(IGF.IGM);
 
-          if (nativeSchema.requiresIndirect() ||
+          if (fnConv.hasIndirectSILResults() ||
+              nativeSchema.requiresIndirect() ||
               errorSchema.shouldReturnTypedErrorIndirectly()) {
             // Return the error indirectly.
             auto buf = IGF.getCalleeTypedErrorResultSlot(silErrorTy);
@@ -4364,8 +4366,9 @@ bool CallEmission::mayReturnTypedErrorDirectly() const {
   SILFunctionConventions fnConv(getCallee().getOrigFunctionType(),
                                 IGF.getSILModule());
   bool mayReturnErrorDirectly = false;
-  if (!convertDirectToIndirectReturn && !fnConv.hasIndirectSILErrorResults() &&
-      fnConv.funcTy->hasErrorResult() && fnConv.isTypedError()) {
+  if (!convertDirectToIndirectReturn && !fnConv.hasIndirectSILResults() &&
+      !fnConv.hasIndirectSILErrorResults() && fnConv.funcTy->hasErrorResult() &&
+      fnConv.isTypedError()) {
     auto errorType =
         fnConv.getSILErrorType(IGF.IGM.getMaximalTypeExpansionContext());
     auto &errorSchema =

lib/IRGen/IRGenSIL.cpp

@@ -2175,7 +2175,8 @@ static void emitEntryPointArgumentsNativeCC(IRGenSILFunction &IGF,
       auto &errorTI = cast<FixedTypeInfo>(IGF.getTypeInfo(inContextErrorType));
       auto &native = resultTI.nativeReturnValueSchema(IGF.IGM);
       auto &nativeError = errorTI.nativeReturnValueSchema(IGF.IGM);
-      if (funcTy->isAsync() || native.requiresIndirect() ||
+      if (funcTy->isAsync() || fnConv.hasIndirectSILResults() ||
+          native.requiresIndirect() ||
           nativeError.shouldReturnTypedErrorIndirectly()) {
         IGF.setCallerTypedErrorResultSlot(
             Address(emission->getCallerTypedErrorResultArgument(),
@@ -3911,7 +3912,8 @@ void IRGenSILFunction::visitFullApplySite(FullApplySite site) {
       auto &resultSchema = resultTI.nativeReturnValueSchema(IGM);
       auto &errorSchema = errorTI.nativeReturnValueSchema(IGM);
 
-      if (isAsync() || substConv.hasIndirectSILErrorResults() ||
+      if (isAsync() || substConv.hasIndirectSILResults() ||
+          substConv.hasIndirectSILErrorResults() ||
           resultSchema.requiresIndirect() ||
           errorSchema.shouldReturnTypedErrorIndirectly()) {
         Explosion errorValue;
@@ -4378,7 +4380,7 @@ static void emitReturnInst(IRGenSILFunction &IGF,
            funcLang == SILFunctionLanguage::C && "Need to handle all cases");
     SILType errorType;
     if (fnType->hasErrorResult() && conv.isTypedError() &&
-        !conv.hasIndirectSILErrorResults()) {
+        !conv.hasIndirectSILResults() && !conv.hasIndirectSILErrorResults()) {
       errorType =
           conv.getSILErrorType(IGF.IGM.getMaximalTypeExpansionContext());
     }
@@ -4433,7 +4435,8 @@ void IRGenSILFunction::visitThrowInst(swift::ThrowInst *i) {
         auto &errorSchema = errorTI.nativeReturnValueSchema(IGM);
 
         Builder.CreateStore(flag, getCallerErrorResultSlot());
-        if (resultSchema.requiresIndirect() ||
+        if (conv.hasIndirectSILResults() || conv.hasIndirectSILErrorResults() ||
+            resultSchema.requiresIndirect() ||
             errorSchema.shouldReturnTypedErrorIndirectly()) {
           errorTI.initialize(*this, errorResult, getCallerTypedErrorResultSlot(),
                              false);

test/IRGen/typed_throws.swift

@@ -144,3 +144,13 @@ func directErrorMergePtrAndInt(x: Bool, y: AnyObject) throws(SmallError) -> (Any
 
   return try directErrorMergePtrAndInt(x: !x, y: y)
 }
+
+// This used to crash at compile time, because it was trying to use a direct
+// error return in combination with an indirect result, which is illegal.
+func genericThrows<T>(x: Bool, y: T) throws(SmallError) -> T {
+  guard x else {
+    throw SmallError(x: 1)
+  }
+
+  return y
+}