Infer AsyncIteratorProtocol.Failure from next() throws.

When inferring the `Failure` associated type from the `next()` witness,
account for the fact that it might itself use typed throws. Use the
specified thrown error type for the inferred witness of `Failure`.

Fixes rdar://125446918.

Author: DougGregor

lib/Sema/AssociatedTypeInference.cpp

@@ -2426,13 +2426,17 @@ AssociatedTypeInference::computeFailureTypeWitness(
   for (const auto &witness : valueWitnesses) {
     if (isAsyncIteratorProtocolNext(witness.first)) {
       if (auto witnessFunc = dyn_cast<AbstractFunctionDecl>(witness.second)) {
+        auto thrownError = witnessFunc->getEffectiveThrownErrorType();
+
         // If it doesn't throw, Failure == Never.
-        if (!witnessFunc->hasThrows())
+        if (!thrownError)
           return AbstractTypeWitness(assocType, ctx.getNeverType());
 
-        // If it isn't 'rethrows', Failure == any Error.
-        if (!witnessFunc->getAttrs().hasAttribute<RethrowsAttr>())
-          return AbstractTypeWitness(assocType, ctx.getErrorExistentialType());
+        // If it isn't 'rethrows', use the thrown error type;.
+        if (!witnessFunc->getAttrs().hasAttribute<RethrowsAttr>()) {
+          return AbstractTypeWitness(assocType,
+                                     dc->mapTypeIntoContext(*thrownError));
+        }
 
         for (auto req : witnessFunc->getGenericSignature().getRequirements()) {
           if (req.getKind() == RequirementKind::Conformance) {

test/Concurrency/async_sequence_rethrows.swift

@@ -51,3 +51,27 @@ extension InheritsAsyncSequence {
     try await self.reduce(into: [Element]()) { $0.append($1) }
   }
 }
+
+// Ensure that we can get the thrown error type from next().
+struct Data { }
+
+struct ErrorSequence<Element, Failure: Error>: AsyncSequence, AsyncIteratorProtocol {
+    let throwError : Failure
+
+    func makeAsyncIterator() -> ErrorSequence<Element, Failure> {
+        self
+    }
+
+    mutating func next() async throws(Failure) -> Element? {
+        throw throwError
+    }
+}
+
+enum MyError: Error {
+    case foo
+}
+
+
+func getASequence() -> any AsyncSequence<Data, MyError> {
+    return ErrorSequence<Data, _>(throwError: MyError.foo) // ERROR: Cannot convert return expression of type 'any Error' to return type 'MyError'
+}