[SILGen] Don't peephole closures with abstraction differences in the thrown error

The prolog and epilog code in SILGen is not set up to deal with
abstraction differences in the thrown error type of closures, so disable
the peephole optimization for closure literals.

Fixes #71401 / rdar://122366566,
which I've stared at for waaaaay too many hours.

Author: DougGregor

lib/SIL/IR/TypeLowering.cpp

@@ -3246,6 +3246,13 @@ TypeConverter::computeLoweredRValueType(TypeExpansionContext forExpansion,
       AnyFunctionType::ExtInfo baseExtInfo;
       if (auto origFnType = origType.getAs<AnyFunctionType>()) {
         baseExtInfo = origFnType->getExtInfo();
+
+        if (baseExtInfo.getThrownError()) {
+          if (auto substThrownError = substFnType->getEffectiveThrownErrorType())
+            baseExtInfo = baseExtInfo.withThrows(true, *substThrownError);
+          else
+            baseExtInfo = baseExtInfo.withThrows(false, Type());
+        }
       } else {
         baseExtInfo = substFnType->getExtInfo();
       }

lib/SILGen/SILGenExpr.cpp

@@ -1903,12 +1903,21 @@ static ManagedValue convertFunctionRepresentation(SILGenFunction &SGF,
   llvm_unreachable("bad representation");
 }
 
+/// Whether the given abstraction pattern as an opaque thrown error.
+static bool hasOpaqueThrownError(const AbstractionPattern &pattern) {
+  if (auto thrownPattern = pattern.getFunctionThrownErrorType())
+    return thrownPattern->isTypeParameterOrOpaqueArchetype();
+
+  return false;
+}
+
 // Ideally our prolog/epilog emission would be able to handle all possible
 // reabstractions and conversions. Until then, this returns true if a closure
 // literal of type `literalType` can be directly emitted by SILGen as
 // `convertedType`.
-static bool canPeepholeLiteralClosureConversion(Type literalType,
-                                                Type convertedType) {
+static bool canPeepholeLiteralClosureConversion(
+    Type literalType, Type convertedType,
+    const std::optional<AbstractionPattern> &closurePattern) {
   auto literalFnType = literalType->getAs<FunctionType>();
   auto convertedFnType = convertedType->getAs<FunctionType>();
 
@@ -1919,22 +1928,28 @@ static bool canPeepholeLiteralClosureConversion(Type literalType,
   if (literalFnType->isEqual(convertedFnType)) {
     return true;
   }
-  
+
   // Are the types equivalent aside from effects (throws) or coeffects
   // (escaping)? Then we should emit the literal as having the destination type
   // (co)effects, even if it doesn't exercise them.
   //
   // TODO: We could also in principle let `async` through here, but that
   // interferes with the implementation of `reasync`.
   auto literalWithoutEffects = literalFnType->getExtInfo().intoBuilder()
-    .withThrows(false, Type())
     .withNoEscape(false)
     .build();
 
   auto convertedWithoutEffects = convertedFnType->getExtInfo().intoBuilder()
-    .withThrows(false, Type())
     .withNoEscape(false)
     .build();
+
+  // If the closure pattern has an abstract thrown error, we are unable to
+  // emit the literal with a difference in the thrown error type.
+  if (!(closurePattern && hasOpaqueThrownError(*closurePattern))) {
+    literalWithoutEffects = literalWithoutEffects.withThrows(false, Type());
+    convertedWithoutEffects = convertedWithoutEffects.withThrows(false, Type());
+  }
+
   if (literalFnType->withExtInfo(literalWithoutEffects)
         ->isEqual(convertedFnType->withExtInfo(convertedWithoutEffects))) {
     return true;
@@ -2000,7 +2015,8 @@ RValue RValueEmitter::visitFunctionConversionExpr(FunctionConversionExpr *e,
 
   if ((isa<AbstractClosureExpr>(subExpr) || isa<CaptureListExpr>(subExpr))
       && canPeepholeLiteralClosureConversion(subExpr->getType(),
-                                             e->getType())) {
+                                             e->getType(),
+                                             C.getAbstractionPattern())) {
     // If we're emitting into a context with a preferred abstraction pattern
     // already, carry that along.
     auto origType = C.getAbstractionPattern();

test/SILGen/typed_throws.swift

@@ -272,6 +272,30 @@ func throwAndPatternMatchCatch<E: Error>(_ body: () throws(E) -> Void) throws(E)
   }
 }
 
+enum MyResult<Success, Failure: Error> {
+  case success(Success)
+  case failure(Failure)
+
+  @inlinable
+  init(catching body: () throws(Failure) -> Success) {
+    do {
+      self = .success(try body())
+    } catch {
+      self = .failure(error)
+    }
+  }
+}
+
+func formerReabstractionCrash() {
+  // CHECK-LABEL: sil private [ossa] @$s12typed_throws24formerReabstractionCrashyyFAA8MyResultOySSs5Error_pGyXEfU_ : $@convention(thin) () -> @owned MyResult<String, any Error> {
+  // CHECK: function_ref @$s12typed_throws24formerReabstractionCrashyyFAA8MyResultOySSs5Error_pGyXEfU_SSyXEfU_ : $@convention(thin) () -> @owned String
+  // CHECK-NEXT: thin_to_thick_function
+  // CHECK-NEXT: convert_function {{%.*}} : $@noescape @callee_guaranteed () -> @owned String to $@noescape @callee_guaranteed () -> (@owned String, @error any Error)
+  let _: MyResult<String, Error>? = {
+    return MyResult{"hello"}
+  }()
+}
+
 // CHECK-LABEL:      sil_vtable MySubclass {
 // CHECK-NEXT:   #MyClass.init!allocator: <E where E : Error> (MyClass.Type) -> (() throws(E) -> ()) throws(E) -> MyClass : @$s12typed_throws10MySubclassC4bodyACyyxYKXE_txYKcs5ErrorRzlufC [override]
 // CHECK-NEXT:  #MyClass.f: (MyClass) -> () throws -> () : @$s12typed_throws10MySubclassC1fyyAA0C5ErrorOYKFAA0C5ClassCADyyKFTV [override]