Erase existential thrown error types

When performing a throwing operation on an opened existential, the
thrown error type could be dependent on the opened existential type,
e.g., if the thrown error type is an associated type of one of the
corresponding protocols. In such cases, type-erase the thrown error
type at the point where it is thrown so that the opened archetype
cannot "escape" the enclosing opened-existential operation via
throwing.

There is an alternative approach we could take that has
`OpenExistentialExpr` handle the type erasure of the thrown error
type. This would make `OpenExistentialExpr` a catch node, which would
type-erase and then rethrow. This is arguably better, because it could
mean fewer places where we do the type erasure and is more in line
with the design of opened archetypes. However, it would also be much
more invasive, and we should be able to do this later.

Fixes rdar://124273722.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -800,6 +800,24 @@ static bool isRethrowingDueToAsyncSequence(DeclContext *rethrowsDC) {
   return true;
 }
 
+/// Type-erase the opened archetypes in the given type, if there is one.
+static Type typeEraseOpenedArchetypes(Type type) {
+  if (!type || !type->hasOpenedExistential())
+    return type;
+
+  const OpenedArchetypeType *root = nullptr;
+  type.visit([&](Type type) {
+    if (auto opened = dyn_cast<OpenedArchetypeType>(type.getPointer())) {
+      root = opened->getRoot();
+    }
+  });
+
+  if (!root)
+    return type;
+
+  return constraints::typeEraseOpenedArchetypesWithRoot(type, root);
+}
+
 /// A type expressing the result of classifying whether a call or function
 /// throws or is async.
 class Classification {
@@ -928,7 +946,7 @@ class Classification {
 
     result.ThrowKind = conditionalKind;
     result.ThrowReason = reason;
-    result.ThrownError = thrownError;
+    result.ThrownError = typeEraseOpenedArchetypes(thrownError);
     return result;
   }
 

test/Concurrency/async_sequence_existential.swift

@@ -0,0 +1,18 @@
+// RUN: %target-swift-frontend  -disable-availability-checking %s -emit-sil -o /dev/null -verify
+
+// RUN: %target-swift-frontend  -disable-availability-checking %s -dump-ast 2>&1 | %FileCheck %s
+
+// REQUIRES: concurrency
+
+extension Error {
+  func printMe() { }
+}
+
+func test(seq: any AsyncSequence) async {
+  // CHECK: "error" interface type="any Error"
+  do {
+    for try await _ in seq { }
+  } catch {
+    error.printMe()
+  }
+}