Revert "Merge pull request swiftlang#75072 from drexin/wip-refactor-te-callemission"

This reverts commit 22b6319, reversing
changes made to 4e4d547.

Author: aschwaighofer

lib/IRGen/CallEmission.h

@@ -110,11 +110,6 @@ class CallEmission {
                                    TemporarySet &temporaries,
                                    bool isOutlined);
 
-  bool mayReturnTypedErrorDirectly() const;
-  void emitToUnmappedExplosionWithDirectTypedError(SILType resultType,
-                                                   llvm::Value *result,
-                                                   Explosion &out);
-
   CallEmission(IRGenFunction &IGF, llvm::Value *selfValue, Callee &&callee)
       : IGF(IGF), selfValue(selfValue), CurCallee(std::move(callee)) {}
 

lib/IRGen/GenCall.cpp

@@ -2756,7 +2756,17 @@ class SyncCallEmission final : public CallEmission {
                                    Explosion &out) override {
     SILFunctionConventions fnConv(getCallee().getOrigFunctionType(),
                                   IGF.getSILModule());
-    bool mayReturnErrorDirectly = mayReturnTypedErrorDirectly();
+    bool mayReturnErrorDirectly = false;
+    if (!convertDirectToIndirectReturn &&
+        !fnConv.hasIndirectSILErrorResults() &&
+        fnConv.funcTy->hasErrorResult() && fnConv.isTypedError()) {
+      auto errorType =
+          fnConv.getSILErrorType(IGF.IGM.getMaximalTypeExpansionContext());
+      auto &errorSchema =
+          IGF.IGM.getTypeInfo(errorType).nativeReturnValueSchema(IGF.IGM);
+
+      mayReturnErrorDirectly = !errorSchema.shouldReturnTypedErrorIndirectly();
+    }
 
     // Bail out immediately on a void result.
     llvm::Value *result = call;
@@ -2803,8 +2813,72 @@ class SyncCallEmission final : public CallEmission {
 
     // Handle direct return of typed errors
     if (mayReturnErrorDirectly && !nativeSchema.requiresIndirect()) {
-      return emitToUnmappedExplosionWithDirectTypedError(resultType, result,
-                                                         out);
+      auto errorType =
+          fnConv.getSILErrorType(IGF.IGM.getMaximalTypeExpansionContext());
+      auto &errorSchema =
+          IGF.IGM.getTypeInfo(errorType).nativeReturnValueSchema(IGF.IGM);
+
+      auto combined =
+          combineResultAndTypedErrorType(IGF.IGM, nativeSchema, errorSchema);
+
+      if (combined.combinedTy->isVoidTy()) {
+        typedErrorExplosion = Explosion();
+        return;
+      }
+
+      Explosion nativeExplosion;
+      extractScalarResults(IGF, result->getType(), result, nativeExplosion);
+      auto values = nativeExplosion.claimAll();
+
+      auto convertIfNecessary = [&](llvm::Type *nativeTy,
+                                    llvm::Value *elt) -> llvm::Value * {
+        auto *eltTy = elt->getType();
+        if (nativeTy->isIntOrPtrTy() && eltTy->isIntOrPtrTy() &&
+            nativeTy->getPrimitiveSizeInBits() !=
+                eltTy->getPrimitiveSizeInBits()) {
+          return IGF.Builder.CreateTruncOrBitCast(elt, nativeTy);
+        }
+        return elt;
+      };
+
+      Explosion errorExplosion;
+      if (!errorSchema.empty()) {
+        if (auto *structTy = dyn_cast<llvm::StructType>(
+                errorSchema.getExpandedType(IGF.IGM))) {
+          for (unsigned i = 0, e = structTy->getNumElements(); i < e; ++i) {
+            llvm::Value *elt = values[combined.errorValueMapping[i]];
+            auto *nativeTy = structTy->getElementType(i);
+            elt = convertIfNecessary(nativeTy, elt);
+            errorExplosion.add(elt);
+          }
+        } else {
+          errorExplosion.add(convertIfNecessary(
+              combined.combinedTy, values[combined.errorValueMapping[0]]));
+        }
+
+        typedErrorExplosion =
+            errorSchema.mapFromNative(IGF.IGM, IGF, errorExplosion, errorType);
+      } else {
+        typedErrorExplosion = std::move(errorExplosion);
+      }
+
+      // If the regular result type is void, there is nothing to explode
+      if (!resultType.isVoid()) {
+        Explosion resultExplosion;
+        if (auto *structTy = dyn_cast<llvm::StructType>(
+                nativeSchema.getExpandedType(IGF.IGM))) {
+          for (unsigned i = 0, e = structTy->getNumElements(); i < e; ++i) {
+            auto *nativeTy = structTy->getElementType(i);
+            resultExplosion.add(convertIfNecessary(nativeTy, values[i]));
+          }
+        } else {
+          resultExplosion.add(
+              convertIfNecessary(combined.combinedTy, values[0]));
+        }
+        out = nativeSchema.mapFromNative(IGF.IGM, IGF, resultExplosion,
+                                         resultType);
+      }
+      return;
     }
 
     if (result->getType()->isVoidTy())
@@ -4361,93 +4435,6 @@ void CallEmission::externalizeArguments(IRGenFunction &IGF, const Callee &callee
   }
 }
 
-bool CallEmission::mayReturnTypedErrorDirectly() const {
-  SILFunctionConventions fnConv(getCallee().getOrigFunctionType(),
-                                IGF.getSILModule());
-  bool mayReturnErrorDirectly = false;
-  if (!convertDirectToIndirectReturn && !fnConv.hasIndirectSILErrorResults() &&
-      fnConv.funcTy->hasErrorResult() && fnConv.isTypedError()) {
-    auto errorType =
-        fnConv.getSILErrorType(IGF.IGM.getMaximalTypeExpansionContext());
-    auto &errorSchema =
-        IGF.IGM.getTypeInfo(errorType).nativeReturnValueSchema(IGF.IGM);
-
-    mayReturnErrorDirectly = !errorSchema.shouldReturnTypedErrorIndirectly();
-  }
-
-  return mayReturnErrorDirectly;
-}
-
-void CallEmission::emitToUnmappedExplosionWithDirectTypedError(
-    SILType resultType, llvm::Value *result, Explosion &out) {
-  SILFunctionConventions fnConv(getCallee().getOrigFunctionType(),
-                                IGF.getSILModule());
-  auto &nativeSchema =
-      IGF.IGM.getTypeInfo(resultType).nativeReturnValueSchema(IGF.IGM);
-  auto errorType =
-      fnConv.getSILErrorType(IGF.IGM.getMaximalTypeExpansionContext());
-  auto &errorSchema =
-      IGF.IGM.getTypeInfo(errorType).nativeReturnValueSchema(IGF.IGM);
-
-  auto combined =
-      combineResultAndTypedErrorType(IGF.IGM, nativeSchema, errorSchema);
-
-  if (combined.combinedTy->isVoidTy()) {
-    typedErrorExplosion = Explosion();
-    return;
-  }
-
-  Explosion nativeExplosion;
-  extractScalarResults(IGF, result->getType(), result, nativeExplosion);
-  auto values = nativeExplosion.claimAll();
-
-  auto convertIfNecessary = [&](llvm::Type *nativeTy,
-                                llvm::Value *elt) -> llvm::Value * {
-    auto *eltTy = elt->getType();
-    if (nativeTy->isIntOrPtrTy() && eltTy->isIntOrPtrTy() &&
-        nativeTy->getPrimitiveSizeInBits() != eltTy->getPrimitiveSizeInBits()) {
-      return IGF.Builder.CreateTruncOrBitCast(elt, nativeTy);
-    }
-    return elt;
-  };
-
-  Explosion errorExplosion;
-  if (!errorSchema.empty()) {
-    if (auto *structTy =
-            dyn_cast<llvm::StructType>(errorSchema.getExpandedType(IGF.IGM))) {
-      for (unsigned i = 0, e = structTy->getNumElements(); i < e; ++i) {
-        llvm::Value *elt = values[combined.errorValueMapping[i]];
-        auto *nativeTy = structTy->getElementType(i);
-        elt = convertIfNecessary(nativeTy, elt);
-        errorExplosion.add(elt);
-      }
-    } else {
-      errorExplosion.add(convertIfNecessary(
-          combined.combinedTy, values[combined.errorValueMapping[0]]));
-    }
-
-    typedErrorExplosion =
-        errorSchema.mapFromNative(IGF.IGM, IGF, errorExplosion, errorType);
-  } else {
-    typedErrorExplosion = std::move(errorExplosion);
-  }
-
-  // If the regular result type is void, there is nothing to explode
-  if (!resultType.isVoid()) {
-    Explosion resultExplosion;
-    if (auto *structTy =
-            dyn_cast<llvm::StructType>(nativeSchema.getExpandedType(IGF.IGM))) {
-      for (unsigned i = 0, e = structTy->getNumElements(); i < e; ++i) {
-        auto *nativeTy = structTy->getElementType(i);
-        resultExplosion.add(convertIfNecessary(nativeTy, values[i]));
-      }
-    } else {
-      resultExplosion.add(convertIfNecessary(combined.combinedTy, values[0]));
-    }
-    out = nativeSchema.mapFromNative(IGF.IGM, IGF, resultExplosion, resultType);
-  }
-}
-
 void CallEmission::setKeyPathAccessorArguments(Explosion &in, bool isOutlined,
                                                Explosion &out) {
   auto origCalleeType = CurCallee.getOrigFunctionType();