[Typed throws] Implement reabstraction thunks that change the error

Introduce SILGen support for reabstractions thunks that change the
error, between indirect and direct errors as well as conversions
amongst error types (e.g., from concrete to `any Error`).

Author: DougGregor

include/swift/SIL/SILFunctionConventions.h

@@ -216,10 +216,7 @@ class SILFunctionConventions {
     return getSILType(funcTy->getErrorResult(), context);
   }
 
-  bool isTypedError() const {
-    return !funcTy->getErrorResult()
-        .getInterfaceType()->isExistentialWithError();
-  }
+  bool isTypedError() const;
 
   /// Returns an array of result info.
   /// Provides convenient access to the underlying SILFunctionType.

lib/SIL/IR/SILFunctionType.cpp

@@ -4943,3 +4943,8 @@ CanSILFunctionType SILFunction::getLoweredFunctionTypeInContext(
   auto funTy = M.Types.getLoweredType(origFunTy , context);
   return cast<SILFunctionType>(funTy.getASTType());
 }
+
+bool SILFunctionConventions::isTypedError() const {
+  return !funcTy->getErrorResult()
+      .getInterfaceType()->isExistentialWithError();
+}

lib/SIL/Verifier/SILVerifier.cpp

@@ -6067,7 +6067,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
 
     if (fnConv.hasIndirectSILErrorResults()) {
-      assert(fnConv.isTypedError());
       auto errorResult = fnConv.getSILErrorType(F.getTypeExpansionContext());
       check("indirect error result", errorResult);
     }

lib/SILGen/SILGenApply.cpp

@@ -5715,7 +5715,6 @@ SILValue SILGenFunction::emitApplyWithRethrow(SILLocation loc, SILValue fn,
   CanSILFunctionType silFnType = substFnType.castTo<SILFunctionType>();
   SILFunctionConventions fnConv(silFnType, SGM.M);
   SILType resultType = fnConv.getSILResultType(getTypeExpansionContext());
-
   if (!silFnType->hasErrorResult()) {
     return B.createApply(loc, fn, subs, args);
   }
@@ -5728,19 +5727,64 @@ SILValue SILGenFunction::emitApplyWithRethrow(SILLocation loc, SILValue fn,
   {
     B.emitBlock(errorBB);
 
-    SILValue error;
-    bool indirectError = fnConv.hasIndirectSILErrorResults();
-
-    if (!indirectError) {
-      error = errorBB->createPhiArgument(
+    // Grab the inner error.
+    SILValue innerError;
+    bool hasInnerIndirectError = fnConv.hasIndirectSILErrorResults();
+    if (!hasInnerIndirectError) {
+      innerError = errorBB->createPhiArgument(
           fnConv.getSILErrorType(getTypeExpansionContext()),
           OwnershipKind::Owned);
+    } else {
+      // FIXME: This probably belongs on SILFunctionConventions.
+      innerError = args[fnConv.getNumIndirectSILResults()];
+    }
+
+    // Convert to the outer error, if we need to.
+    SILValue outerError;
+    SILType innerErrorType = innerError->getType().getObjectType();
+    SILType outerErrorType = F.mapTypeIntoContext(
+        F.getConventions().getSILErrorType(getTypeExpansionContext()));
+    if (IndirectErrorResult && IndirectErrorResult == innerError) {
+      // Fast path: we aliased the indirect error result slot because both are
+      // indirect and the types matched, so we are done.
+    } else if (!IndirectErrorResult && !hasInnerIndirectError &&
+               innerErrorType == outerErrorType) {
+      // Fast path: both have a direct error result and the types line up, so
+      // rethrow the inner error.
+      outerError = innerError;
+    } else {
+      // The error requires some kind of translation.
+
+      // Load the inner error, if it was returned indirectly.
+      if (innerError->getType().isAddress()) {
+        innerError = emitLoad(loc, innerError, getTypeLowering(innerErrorType),
+                              SGFContext(), IsTake).forward(*this);
+      }
+
+      // If we need to convert the error type, do so now.
+      if (innerErrorType != outerErrorType) {
+        auto conversion = Conversion::getOrigToSubst(
+            AbstractionPattern(innerErrorType.getASTType()),
+            outerErrorType.getASTType(),
+            outerErrorType);
+        outerError = emitConvertedRValue(loc, conversion, SGFContext(),
+            [innerError](SILGenFunction &SGF, SILLocation loc, SGFContext C) {
+              return ManagedValue::forForwardedRValue(SGF, innerError);
+            }).forward(*this);
+      }
+
+      // If the outer error is returned indirectly, copy from the converted
+      // inner error to the outer error slot.
+      if (IndirectErrorResult) {
+        emitSemanticStore(loc, outerError, IndirectErrorResult, 
+                          getTypeLowering(outerErrorType), IsInitialization);
+      }
     }
 
     Cleanups.emitCleanupsForReturn(CleanupLocation(loc), IsForUnwind);
 
-    if (!indirectError)
-      B.createThrow(loc, error);
+    if (!IndirectErrorResult)
+      B.createThrow(loc, outerError);
     else
       B.createThrowAddr(loc);
   }

lib/SILGen/SILGenFunction.h

@@ -2273,7 +2273,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Used for emitting SILArguments of bare functions, such as thunks.
   void collectThunkParams(
       SILLocation loc, SmallVectorImpl<ManagedValue> &params,
-      SmallVectorImpl<ManagedValue> *indirectResultParams = nullptr);
+      SmallVectorImpl<ManagedValue> *indirectResultParams = nullptr,
+      SmallVectorImpl<ManagedValue> *indirectErrorParams = nullptr);
 
   /// Build the type of a function transformation thunk.
   CanSILFunctionType buildThunkType(CanSILFunctionType &sourceType,

lib/SILGen/SILGenPoly.cpp

@@ -850,7 +850,8 @@ ManagedValue Transform::transformTuple(ManagedValue inputTuple,
 
 void SILGenFunction::collectThunkParams(
     SILLocation loc, SmallVectorImpl<ManagedValue> &params,
-    SmallVectorImpl<ManagedValue> *indirectResults) {
+    SmallVectorImpl<ManagedValue> *indirectResults,
+    SmallVectorImpl<ManagedValue> *indirectErrors) {
   // Add the indirect results.
   for (auto resultTy : F.getConventions().getIndirectSILResultTypes(
            getTypeExpansionContext())) {
@@ -864,6 +865,19 @@ void SILGenFunction::collectThunkParams(
       indirectResults->push_back(ManagedValue::forLValue(arg));
   }
 
+  if (F.getConventions().hasIndirectSILErrorResults()) {
+    assert(F.getConventions().getNumIndirectSILErrorResults() == 1);
+    auto paramTy = F.mapTypeIntoContext(
+                       F.getConventions().getSILErrorType(getTypeExpansionContext()));
+    auto inContextParamTy = F.getLoweredType(paramTy.getASTType())
+                                .getCategoryType(paramTy.getCategory());
+    SILArgument *arg = F.begin()->createFunctionArgument(inContextParamTy);
+    if (indirectErrors)
+      indirectErrors->push_back(ManagedValue::forLValue(arg));
+
+    IndirectErrorResult = arg;
+  }
+
   // Add the parameters.
   auto paramTypes = F.getLoweredFunctionType()->getParameters();
   for (auto param : paramTypes) {
@@ -4831,6 +4845,31 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
                      outputSubstType.getResult(),
                      fnType, thunkType);
 
+  // If the function we're calling has as indirect error result, create an
+  // argument for it.
+  SILValue innerIndirectErrorAddr;
+  if (auto innerError = fnType->getOptionalErrorResult()) {
+    if (innerError->getConvention() == ResultConvention::Indirect) {
+      auto loweredErrorResultType = SGF.getSILType(*innerError, fnType);
+      if (SGF.IndirectErrorResult &&
+          SGF.IndirectErrorResult->getType().getObjectType()
+              == loweredErrorResultType) {
+        // The type of the indirect error is the same for both the inner
+        // function and the thunk, so we can re-use the indirect error slot.
+        innerIndirectErrorAddr = SGF.IndirectErrorResult;
+      } else {
+        // The type of the indirect error in the inner function differs from
+        // that of the thunk, or the thunk has a direct error, so allocate a
+        // stack location for the inner indirect error.
+        innerIndirectErrorAddr =
+            SGF.B.createAllocStack(loc, loweredErrorResultType);
+        SGF.enterDeallocStackCleanup(innerIndirectErrorAddr);
+      }
+
+      argValues.push_back(innerIndirectErrorAddr);
+    }
+  }
+
   // Add the rest of the arguments.
   forwardFunctionArguments(SGF, loc, fnType, args, argValues);
 

lib/SILGen/SILGenStmt.cpp

@@ -1567,14 +1567,19 @@ void SILGenFunction::emitThrow(SILLocation loc, ManagedValue exnMV,
         getModule().getSwiftModule()->conformsToProtocol(
           exn->getType().getASTType(), getASTContext().getErrorDecl())
       };
+
       exnMV = emitExistentialErasure(
           loc,
           exn->getType().getASTType(),
-          getTypeLowering(exn->getType()),
+          getTypeLowering(exn->getType().getObjectType()),
           getTypeLowering(existentialBoxType),
           getASTContext().AllocateCopy(conformances),
           SGFContext(),
           [&](SGFContext C) -> ManagedValue {
+            if (exn->getType().isAddress()) {
+              return emitLoad(loc, exn, getTypeLowering(exn->getType().getObjectType()), C, IsTake);
+            }
+
             return ManagedValue::forForwardedRValue(*this, exn);
           });
 

test/SILGen/typed_throws_generic.swift

@@ -94,4 +94,89 @@ public func genericForceTry<E>(fn: () throws(E) -> ()) {
 // CHECK: end_borrow [[FN_BORROW]] : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>
 // CHECK: dealloc_stack [[ERROR]] : $*E
 // CHECK: destroy_value [[FN]] : $@noescape @callee_guaranteed @substituted <τ_0_0> () -> @error_indirect τ_0_0 for <E>
-// CHECK: unreachable
+// CHECK: unreachable
+
+enum MyError: Error {
+case fail
+}
+
+func passthroughCall<T, E>(_ body: () throws(E) -> T) throws(E) -> T {
+  try body()
+}
+
+func five() -> Int { 5 }
+
+func fiveOrBust() throws -> Int { 5 }
+
+func fiveOrTypedBust() throws(MyError) -> Int { 5 }
+
+// CHECK-LABEL: sil hidden [ossa] @$s20typed_throws_generic23reabstractAsNonthrowingSiyF
+func reabstractAsNonthrowing() -> Int {
+  // CHECK: [[FN:%.*]] = convert_escape_to_noescape [not_guaranteed] [[PRIOR_FN:%.*]] : $@callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <Never, Int> to $@noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <Never, Int>
+  // CHECK: [[CALLEE:%.*]] = function_ref @$s20typed_throws_generic15passthroughCallyxxyq_YKXEq_YKs5ErrorR_r0_lF : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Error> (@guaranteed @noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <τ_0_1, τ_0_0>) -> (@out τ_0_0, @error_indirect τ_0_1)
+  // CHECK: [[ERROR_SLOT:%.*]] = alloc_stack $Never
+  // CHECK: try_apply [[CALLEE]]<Int, Never>(%0, [[ERROR_SLOT]], [[FN]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Error> (@guaranteed @noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <τ_0_1, τ_0_0>) -> (@out τ_0_0, @error_indirect τ_0_1), normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+  passthroughCall(five)
+
+  // CHECK: [[NORMAL_BB]]
+  // CHECK: dealloc_stack [[ERROR_SLOT]] : $*Never
+
+  // CHECK: [[ERROR_BB]]:
+  // CHECK-NEXT: unreachable
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s20typed_throws_generic20reabstractAsThrowingSiyKF
+func reabstractAsThrowing() throws -> Int {
+  // CHECK: [[FN:%.*]] = convert_escape_to_noescape [not_guaranteed] [[PRIOR_FN:%.*]] : $@callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <any Error, Int> to $@noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <any Error, Int>
+  // CHECK: [[CALLEE:%.*]] = function_ref @$s20typed_throws_generic15passthroughCallyxxyq_YKXEq_YKs5ErrorR_r0_lF : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Error> (@guaranteed @noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <τ_0_1, τ_0_0>) -> (@out τ_0_0, @error_indirect τ_0_1)
+  // CHECK: [[ERROR_SLOT:%.*]] = alloc_stack $any Error
+  // CHECK: try_apply [[CALLEE]]<Int, any Error>(%1, [[ERROR_SLOT]], [[FN]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Error> (@guaranteed @noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <τ_0_1, τ_0_0>) -> (@out τ_0_0, @error_indirect τ_0_1), normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+  try passthroughCall(fiveOrBust)
+
+  // CHECK: [[NORMAL_BB]]
+  // CHECK: dealloc_stack [[ERROR_SLOT]] : $*any Error
+
+  // CHECK: [[ERROR_BB]]:
+  // CHECK: throw [[ERR:%.*]] : $any Error
+}
+
+// CHECK-LABEL: sil shared [transparent] [serialized] [reabstraction_thunk] [ossa] @$sSis5Error_pIgdzo_SisAA_pIegrzr_TR : $@convention(thin) (@guaranteed @noescape @callee_guaranteed () -> (Int, @error any Error)) -> (@out Int, @error_indirect any Error)
+// CHECK: bb0([[ARG:%.*]] : $*Int, [[OUTER_ERROR_SLOT:%.*]] : $*any Error, [[INNER_FN:%.*]] : @guaranteed $@noescape @callee_guaranteed () -> (Int, @error any Error)):
+// CHECK: try_apply [[INNER_FN]]() : $@noescape @callee_guaranteed () -> (Int, @error any Error), normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+
+// CHECK: [[NORMAL_BB]]([[RESULT:%.*]] : $Int):
+// CHECK-NEXT: store [[RESULT]] to [trivial] [[ARG]] : $*Int
+// CHECK-NEXT: [[VOID_RESULT:%.*]] = tuple ()
+// CHECK-NEXT:  return [[VOID_RESULT]] : $()
+
+// CHECK: [[ERROR_BB]]([[INNER_ERROR:%.*]] : @owned $any Error):
+// CHECK-NEXT:  store [[INNER_ERROR]] to [init] [[OUTER_ERROR_SLOT]] : $*any Error
+// CHECK-NEXT:  throw_addr
+
+// CHECK-LABEL: sil hidden [ossa] @$s20typed_throws_generic28reabstractAsConcreteThrowingSiyKF : $@convention(thin) () -> (Int, @error any Error)
+func reabstractAsConcreteThrowing() throws -> Int {
+  // CHECK: [[FN:%.*]] = convert_escape_to_noescape [not_guaranteed] [[PRIOR_FN:%.*]] : $@callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <MyError, Int> to $@noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <MyError, Int>
+  // CHECK: [[CALLEE:%.*]] = function_ref @$s20typed_throws_generic15passthroughCallyxxyq_YKXEq_YKs5ErrorR_r0_lF : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Error> (@guaranteed @noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <τ_0_1, τ_0_0>) -> (@out τ_0_0, @error_indirect τ_0_1)
+  // CHECK: [[ERROR_SLOT:%.*]] = alloc_stack $MyError
+  // CHECK: try_apply [[CALLEE]]<Int, MyError>(%1, [[ERROR_SLOT]], [[FN]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Error> (@guaranteed @noescape @callee_guaranteed @substituted <τ_0_0, τ_0_1> () -> (@out τ_0_1, @error_indirect τ_0_0) for <τ_0_1, τ_0_0>) -> (@out τ_0_0, @error_indirect τ_0_1), normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+  try passthroughCall(fiveOrTypedBust)
+
+  // CHECK: [[NORMAL_BB]]
+  // CHECK-NEXT: dealloc_stack [[ERROR_SLOT]] : $*MyError
+
+  // CHECK: [[ERROR_BB]]:
+  // CHECK: alloc_existential_box $any Error, $MyError
+  // CHECK-NEXT: project_existential_box $MyError in
+  // CHECK: throw [[ERR:%.*]] : $any Error
+}
+
+// CHECK-LABEL: sil shared [transparent] [serialized] [reabstraction_thunk] [ossa] @$sSi20typed_throws_generic7MyErrorOIgdzo_SiACIegrzr_TR : $@convention(thin) (@guaranteed @noescape @callee_guaranteed () -> (Int, @error MyError)) -> (@out Int, @error_indirect MyError) {
+// CHECK: bb0([[RESULT_ADDR:%.*]] : $*Int, [[OUTER_ERROR:%.*]] : $*MyError, [[FN:%.*]] : @guaranteed $@noescape @callee_guaranteed () -> (Int, @error MyError)):
+// CHECK-NEXT: try_apply [[FN]]() : $@noescape @callee_guaranteed () -> (Int, @error MyError), normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+
+// CHECK: [[NORMAL_BB]]([[INNER_RESULT:%.*]] : $Int):
+// CHECK-NEXT: store [[INNER_RESULT]] to [trivial] [[RESULT_ADDR]] : $*Int
+
+// CHECK: [[ERROR_BB]]([[INNER_ERROR:%.*]] : $MyError):
+// CHECK-NEXT: store [[INNER_ERROR]] to [trivial] [[OUTER_ERROR]] : $*MyError
+// CHECK-NEXT: throw_addr