SILGen: Emit indirect error result argument

slavapestov · slavapestov · commit 581776b9975b · 2023-10-27T17:37:43.000-04:00
diff --git a/lib/SILGen/SILGenBackDeploy.cpp b/lib/SILGen/SILGenBackDeploy.cpp
@@ -237,7 +237,8 @@ void SILGenFunction::emitBackDeploymentThunk(SILDeclRef thunk) {
     paramsForForwarding.emplace_back(param.forward(*this));
   }
 
-  prepareEpilog(getResultInterfaceType(AFD),
+  prepareEpilog(AFD,
+                getResultInterfaceType(AFD),
                 AFD->getEffectiveThrownErrorType(),
                 CleanupLocation(AFD));
 
diff --git a/lib/SILGen/SILGenBridging.cpp b/lib/SILGen/SILGenBridging.cpp
@@ -2134,7 +2134,10 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
   // Set up the throw destination if necessary.
   CleanupLocation cleanupLoc(fd);
   if (thrownErrorType) {
-    prepareRethrowEpilog(*thrownErrorType, cleanupLoc);
+    prepareRethrowEpilog(fd,
+                         AbstractionPattern(*thrownErrorType),
+                         *thrownErrorType,
+                         cleanupLoc);
   }
 
   SILValue result;
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
@@ -658,10 +658,11 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   assert(selfLV);
 
   // Emit the prolog.
-  emitBasicProlog(ctor->getParameters(),
+  emitBasicProlog(ctor,
+                  ctor->getParameters(),
                   /*selfParam=*/nullptr,
-                  ctor->getResultInterfaceType(), ctor,
-                  ctor->hasThrows(),
+                  ctor->getResultInterfaceType(),
+                  ctor->getEffectiveThrownErrorType(),
                   ctor->getThrowsLoc(),
                   /*ignored parameters*/ 1);
   emitConstructorMetatypeArg(*this, ctor);
@@ -680,7 +681,9 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   // Create a basic block to jump to for the implicit 'self' return.
   // We won't emit this until after we've emitted the body.
   // The epilog takes a void return because the return of 'self' is implicit.
-  prepareEpilog(llvm::None, ctor->getEffectiveThrownErrorType(),
+  prepareEpilog(ctor,
+                llvm::None,
+                ctor->getEffectiveThrownErrorType(),
                 CleanupLocation(ctor));
 
   // If the constructor can fail, set up an alternative epilog for constructor
@@ -1105,9 +1108,11 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
 
   // Emit the prolog for the non-self arguments.
   // FIXME: Handle self along with the other body patterns.
-  uint16_t ArgNo = emitBasicProlog(ctor->getParameters(), /*selfParam=*/nullptr,
-                                   TupleType::getEmpty(F.getASTContext()), ctor,
-                                   ctor->hasThrows(), ctor->getThrowsLoc(),
+  uint16_t ArgNo = emitBasicProlog(ctor,
+                                   ctor->getParameters(), /*selfParam=*/nullptr,
+                                   TupleType::getEmpty(F.getASTContext()),
+                                   ctor->getEffectiveThrownErrorType(),
+                                   ctor->getThrowsLoc(),
                                    /*ignored parameters*/ 1);
 
   SILType selfTy = getLoweredLoadableType(selfDecl->getTypeInContext());
@@ -1185,7 +1190,9 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
 
   // Create a basic block to jump to for the implicit 'self' return.
   // We won't emit the block until after we've emitted the body.
-  prepareEpilog(llvm::None, ctor->getEffectiveThrownErrorType(),
+  prepareEpilog(ctor,
+                llvm::None,
+                ctor->getEffectiveThrownErrorType(),
                 CleanupLocation(endOfInitLoc));
 
   auto resultType = ctor->mapTypeIntoContext(ctor->getResultInterfaceType());
@@ -1680,7 +1687,7 @@ void SILGenFunction::emitIVarInitializer(SILDeclRef ivarInitializer) {
   VarLocs[selfDecl] = VarLoc::get(selfArg);
 
   auto cleanupLoc = CleanupLocation(loc);
-  prepareEpilog(llvm::None, llvm::None, cleanupLoc);
+  prepareEpilog(cd, llvm::None, llvm::None, cleanupLoc);
 
   // Emit the initializers.
   emitMemberInitializers(cd, selfDecl, cd);
@@ -1732,9 +1739,11 @@ void SILGenFunction::emitInitAccessor(AccessorDecl *accessor) {
   auto accessedProperties = accessor->getAccessedProperties();
 
   // Emit `newValue` argument.
-  emitBasicProlog(accessor->getParameters(), /*selfParam=*/nullptr,
-                  TupleType::getEmpty(F.getASTContext()), accessor,
-                  /*throws=*/false, /*throwsLoc=*/SourceLoc(),
+  emitBasicProlog(accessor,
+                  accessor->getParameters(), /*selfParam=*/nullptr,
+                  TupleType::getEmpty(F.getASTContext()),
+                  /*errorType=*/llvm::None,
+                  /*throwsLoc=*/SourceLoc(),
                   /*ignored parameters*/
                   accessedProperties.size());
 
@@ -1750,7 +1759,8 @@ void SILGenFunction::emitInitAccessor(AccessorDecl *accessor) {
     }
   }
 
-  prepareEpilog(accessor->getResultInterfaceType(),
+  prepareEpilog(accessor,
+                accessor->getResultInterfaceType(),
                 accessor->getEffectiveThrownErrorType(),
                 CleanupLocation(accessor));
 
diff --git a/lib/SILGen/SILGenDestructor.cpp b/lib/SILGen/SILGenDestructor.cpp
@@ -45,7 +45,7 @@ void SILGenFunction::emitDestroyingDestructor(DestructorDecl *dd) {
   // Create a basic block to jump to for the implicit destruction behavior
   // of releasing the elements and calling the superclass destructor.
   // We won't actually emit the block until we finish with the destructor body.
-  prepareEpilog(llvm::None, llvm::None, CleanupLocation(Loc));
+  prepareEpilog(dd, llvm::None, llvm::None, CleanupLocation(Loc));
 
   auto cleanupLoc = CleanupLocation(Loc);
 
@@ -248,7 +248,7 @@ void SILGenFunction::emitDeallocatingMoveOnlyDestructor(DestructorDecl *dd) {
   // Create a basic block to jump to for the implicit destruction behavior
   // of releasing the elements and calling the superclass destructor.
   // We won't actually emit the block until we finish with the destructor body.
-  prepareEpilog(llvm::None, llvm::None, CleanupLocation(loc));
+  prepareEpilog(dd, llvm::None, llvm::None, CleanupLocation(loc));
 
   auto cleanupLoc = CleanupLocation(loc);
 
@@ -286,7 +286,7 @@ void SILGenFunction::emitIVarDestroyer(SILDeclRef ivarDestroyer) {
   assert(selfValue);
 
   auto cleanupLoc = CleanupLocation(loc);
-  prepareEpilog(llvm::None, llvm::None, cleanupLoc);
+  prepareEpilog(cd, llvm::None, llvm::None, cleanupLoc);
   {
     Scope S(*this, cleanupLoc);
     // Self is effectively guaranteed for the duration of any destructor.  For
@@ -577,7 +577,7 @@ void SILGenFunction::emitObjCDestructor(SILDeclRef dtor) {
   // Create a basic block to jump to for the implicit destruction behavior
   // of releasing the elements and calling the superclass destructor.
   // We won't actually emit the block until we finish with the destructor body.
-  prepareEpilog(llvm::None, llvm::None, CleanupLocation(loc));
+  prepareEpilog(dd, llvm::None, llvm::None, CleanupLocation(loc));
 
   emitProfilerIncrement(dd->getTypecheckedBody());
   // Emit the destructor body.
diff --git a/lib/SILGen/SILGenEpilog.cpp b/lib/SILGen/SILGenEpilog.cpp
@@ -20,9 +20,11 @@
 using namespace swift;
 using namespace Lowering;
 
-void SILGenFunction::prepareEpilog(llvm::Optional<Type> directResultType,
-                                   llvm::Optional<Type> exnType,
-                                   CleanupLocation CleanupL) {
+void SILGenFunction::prepareEpilog(DeclContext *DC,
+                                   llvm::Optional<Type> directResultType,
+                                   llvm::Optional<Type> errorType,
+                                   CleanupLocation CleanupL,
+                                   llvm::Optional<AbstractionPattern> origClosureType) {
   auto *epilogBB = createBasicBlock();
 
   // If we have any direct results, receive them via BB arguments.
@@ -63,8 +65,14 @@ void SILGenFunction::prepareEpilog(llvm::Optional<Type> directResultType,
 
   ReturnDest = JumpDest(epilogBB, getCleanupsDepth(), CleanupL);
 
-  if (exnType) {
-    prepareRethrowEpilog(*exnType, CleanupL);
+  if (errorType) {
+    auto genericSig = DC->getGenericSignatureOfContext();
+    AbstractionPattern origErrorType = origClosureType
+      ? *origClosureType->getFunctionThrownErrorType()
+      : AbstractionPattern(genericSig.getCanonicalSignature(),
+                           (*errorType)->getCanonicalType());
+
+    prepareRethrowEpilog(DC, origErrorType, *errorType, CleanupL);
   }
 
   if (F.getLoweredFunctionType()->isCoroutine()) {
@@ -73,10 +81,15 @@ void SILGenFunction::prepareEpilog(llvm::Optional<Type> directResultType,
 }
 
 void SILGenFunction::prepareRethrowEpilog(
-    Type exnType, CleanupLocation cleanupLoc) {
-  SILType loweredExnType = getLoweredType(exnType);
+    DeclContext *dc, AbstractionPattern origErrorType, Type errorType,
+    CleanupLocation cleanupLoc) {
+
   SILBasicBlock *rethrowBB = createBasicBlock(FunctionSection::Postmatter);
-  rethrowBB->createPhiArgument(loweredExnType, OwnershipKind::Owned);
+  if (!IndirectErrorResult) {
+    SILType loweredErrorType = getLoweredType(origErrorType, errorType);
+    rethrowBB->createPhiArgument(loweredErrorType, OwnershipKind::Owned);
+  }
+
   ThrowDest = JumpDest(rethrowBB, getCleanupsDepth(), cleanupLoc);
 }
 
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
@@ -1043,15 +1043,18 @@ void SILGenFunction::emitFunction(FuncDecl *fd) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(fd);
 
   auto captureInfo = SGM.M.Types.getLoweredLocalCaptures(SILDeclRef(fd));
-  emitProlog(captureInfo, fd->getParameters(), fd->getImplicitSelfDecl(), fd,
-             fd->getResultInterfaceType(), fd->hasThrows(), fd->getThrowsLoc());
+  emitProlog(fd, captureInfo, fd->getParameters(), fd->getImplicitSelfDecl(),
+             fd->getResultInterfaceType(), fd->getEffectiveThrownErrorType(),
+             fd->getThrowsLoc());
 
   if (fd->isDistributedActorFactory()) {
     // Synthesize the factory function body
     emitDistributedActorFactory(fd);
   } else {
-    prepareEpilog(fd->getResultInterfaceType(),
-                  fd->getEffectiveThrownErrorType(), CleanupLocation(fd));
+    prepareEpilog(fd,
+                  fd->getResultInterfaceType(),
+                  fd->getEffectiveThrownErrorType(),
+                  CleanupLocation(fd));
 
     if (fd->requiresUnavailableDeclABICompatibilityStubs())
       emitApplyOfUnavailableCodeReached();
@@ -1071,15 +1074,17 @@ void SILGenFunction::emitFunction(FuncDecl *fd) {
 void SILGenFunction::emitClosure(AbstractClosureExpr *ace) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(ace);
   OrigFnType = SGM.M.Types.getConstantAbstractionPattern(SILDeclRef(ace));
-  
+
   auto resultIfaceTy = ace->getResultType()->mapTypeOutOfContext();
+  llvm::Optional<Type> errorIfaceTy;
+  if (auto optErrorTy = ace->getEffectiveThrownType())
+    errorIfaceTy = (*optErrorTy)->mapTypeOutOfContext();
   auto captureInfo = SGM.M.Types.getLoweredLocalCaptures(
     SILDeclRef(ace));
-  emitProlog(captureInfo, ace->getParameters(), /*selfParam=*/nullptr,
-             ace, resultIfaceTy, ace->isBodyThrowing(), ace->getLoc(),
-             OrigFnType);
-  prepareEpilog(resultIfaceTy, ace->getEffectiveThrownType(),
-                CleanupLocation(ace));
+  emitProlog(ace, captureInfo, ace->getParameters(), /*selfParam=*/nullptr,
+             resultIfaceTy, errorIfaceTy, ace->getLoc(), OrigFnType);
+  prepareEpilog(ace, resultIfaceTy, errorIfaceTy,
+                CleanupLocation(ace), OrigFnType);
 
   emitProfilerIncrement(ace);
   if (auto *ce = dyn_cast<ClosureExpr>(ace)) {
@@ -1553,15 +1558,15 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, Expr *value,
 
   auto captureInfo = SGM.M.Types.getLoweredLocalCaptures(function);
   auto interfaceType = value->getType()->mapTypeOutOfContext();
-  emitProlog(captureInfo, params, /*selfParam=*/nullptr,
-             dc, interfaceType, /*throws=*/false, SourceLoc());
+  emitProlog(dc, captureInfo, params, /*selfParam=*/nullptr, interfaceType,
+             /*errorType=*/llvm::None, SourceLoc());
   if (EmitProfilerIncrement) {
     // Emit a profiler increment for the top-level value, not looking through
     // any function conversions. This is necessary as the counter would have
     // been recorded for this expression, not the sub-expression.
     emitProfilerIncrement(topLevelValue);
   }
-  prepareEpilog(interfaceType, llvm::None, CleanupLocation(Loc));
+  prepareEpilog(dc, interfaceType, llvm::None, CleanupLocation(Loc));
 
   {
     llvm::Optional<SILGenFunction::OpaqueValueRAII> opaqueValue;
@@ -1621,10 +1626,14 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, VarDecl *var) {
     }
   }
 
-  emitBasicProlog(/*paramList*/ nullptr, /*selfParam*/ nullptr,
-                  interfaceType, dc, /*throws=*/ false,SourceLoc(),
+  emitBasicProlog(dc,
+                  /*paramList*/ nullptr,
+                  /*selfParam*/ nullptr,
+                  interfaceType,
+                  /*errorType=*/llvm::None,
+                  /*throwsLoc=*/SourceLoc(),
                   /*ignored parameters*/ 0);
-  prepareEpilog(interfaceType, llvm::None, CleanupLocation(loc));
+  prepareEpilog(dc, interfaceType, llvm::None, CleanupLocation(loc));
 
   auto pbd = var->getParentPatternBinding();
   const auto i = pbd->getPatternEntryIndexForVarDecl(var);
@@ -1676,11 +1685,11 @@ void SILGenFunction::emitGeneratorFunction(
 
   auto *dc = function.getDecl()->getInnermostDeclContext();
   auto captureInfo = SGM.M.Types.getLoweredLocalCaptures(function);
-  emitProlog(captureInfo, ParameterList::createEmpty(getASTContext()),
-             /*selfParam=*/nullptr, dc, resultInterfaceType, /*throws=*/false,
-             SourceLoc(), pattern);
+  emitProlog(dc, captureInfo, ParameterList::createEmpty(getASTContext()),
+             /*selfParam=*/nullptr, resultInterfaceType,
+             /*errorType=*/llvm::None, SourceLoc(), pattern);
 
-  prepareEpilog(resultInterfaceType, llvm::None, CleanupLocation(loc));
+  prepareEpilog(dc, resultInterfaceType, llvm::None, CleanupLocation(loc));
 
   emitStmt(body);
 
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -392,6 +392,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// postmatter and takes a BB argument of the exception type.
   JumpDest ThrowDest = JumpDest::invalid();
 
+  /// Support for typed throws.
+  SILArgument *IndirectErrorResult = nullptr;
+
   /// The destination for coroutine unwinds.  The block will always
   /// be in the postmatter.
   JumpDest CoroutineUnwindDest = JumpDest::invalid();
@@ -1144,15 +1147,15 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// emitProlog - Generates prolog code to allocate and clean up mutable
   /// storage for closure captures and local arguments.
   void
-  emitProlog(CaptureInfo captureInfo, ParameterList *paramList,
-             ParamDecl *selfParam, DeclContext *DC, Type resultType,
-             bool throws, SourceLoc throwsLoc,
+  emitProlog(DeclContext *DC, CaptureInfo captureInfo, ParameterList *paramList,
+             ParamDecl *selfParam, Type resultType,
+             llvm::Optional<Type> errorType, SourceLoc throwsLoc,
              llvm::Optional<AbstractionPattern> origClosureType = llvm::None);
   /// A simpler version of emitProlog
   /// \returns the number of variables in paramPatterns.
   uint16_t emitBasicProlog(
-      ParameterList *paramList, ParamDecl *selfParam, Type resultType,
-      DeclContext *DC, bool throws, SourceLoc throwsLoc,
+      DeclContext *DC, ParameterList *paramList, ParamDecl *selfParam,
+      Type resultType, llvm::Optional<Type> errorType, SourceLoc throwsLoc,
       unsigned numIgnoredTrailingParameters,
       llvm::Optional<AbstractionPattern> origClosureType = llvm::None);
 
@@ -1169,17 +1172,25 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Create (but do not emit) the epilog branch, and save the
   /// current cleanups depth as the destination for return statement branches.
   ///
+  /// \param dc  The declaration context whose generic signature to use for
+  ///            interpreting interface types.
   /// \param directResultType  If given a value, the epilog block will be
   ///                    created with arguments for each direct result of this
   ///                    function, corresponding to the formal return type.
-  /// \param exnType  If not None, create an error epilog block with the given
-  ///                 exception type.
+  /// \param errorType  If not None, create an error epilog block with the given
+  ///                   thrown error type.
   /// \param L           The SILLocation which should be associated with
   ///                    cleanup instructions.
-  void prepareEpilog(llvm::Optional<Type> directResultType, 
-                     llvm::Optional<Type> exnType,
-                     CleanupLocation L);
-  void prepareRethrowEpilog(Type exnType, CleanupLocation l);
+  /// \param origClosureType Overrides the abstraction pattern for lowering the
+  ///                        error type.
+  void prepareEpilog(DeclContext *dc,
+                     llvm::Optional<Type> directResultType, 
+                     llvm::Optional<Type> errorType,
+                     CleanupLocation L,
+                     llvm::Optional<AbstractionPattern> origClosureType = llvm::None);
+  void prepareRethrowEpilog(DeclContext *dc,
+                            AbstractionPattern origErrorType,
+                            Type errorType, CleanupLocation l);
   void prepareCoroutineUnwindEpilog(CleanupLocation l);
   
   /// Branch to and emit the epilog basic block. This will fuse
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
diff --git a/lib/SILGen/SILGenTopLevel.cpp b/lib/SILGen/SILGenTopLevel.cpp
diff --git a/test/SILGen/typed_throws_generic.swift b/test/SILGen/typed_throws_generic.swift

Original file line number	Diff line number	Diff line change
`@@ -237,7 +237,8 @@ void SILGenFunction::emitBackDeploymentThunk(SILDeclRef thunk) {`
`237`	`237`	`paramsForForwarding.emplace_back(param.forward(*this));`
`238`	`238`	`}`
`239`	`239`
`240`		`- prepareEpilog(getResultInterfaceType(AFD),`
	`240`	`+ prepareEpilog(AFD,`
	`241`	`+ getResultInterfaceType(AFD),`
`241`	`242`	`AFD->getEffectiveThrownErrorType(),`
`242`	`243`	`CleanupLocation(AFD));`
`243`	`244`