Introduce an egregious source-compatibility hack for `AsyncSequence.f…

…latMap`

Allow `AsyncSequence.flatMap` to be defined with "incorrect" availability,
meaning that the function can refer to the `Failure` associated type
in its where clause even though the function is back-deployed to
before the `Failure` associated type was introduced.

We believe this is safe, and that this notion can be generalized to any
use of an associated type in a same-type constraint of a function
(yes, it sounds weird), but for now introduce a narrower hack to see
how things work in practice and whether it addresses all of the
source-compatibility concerns we've uncovered.

lib/Sema/TypeCheckAccess.cpp

@@ -2014,6 +2014,25 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
                              Where.withReason(reason), flags);
   }
 
+  /// Identify the AsyncSequence.flatMap set of functions from the
+  /// _Concurrency module.
+  static bool isAsyncSequenceFlatMap(const GenericContext *gc) {
+    auto func = dyn_cast<FuncDecl>(gc);
+    if (!func)
+      return false;
+
+    auto proto = func->getDeclContext()->getSelfProtocolDecl();
+    if (!proto ||
+        !proto->isSpecificProtocol(KnownProtocolKind::AsyncSequence))
+      return false;
+
+    ASTContext &ctx = proto->getASTContext();
+    if (func->getModuleContext()->getName() != ctx.Id_Concurrency)
+      return false;
+
+    return !func->getName().isSimpleName("flatMap");
+  }
+
   void checkGenericParams(const GenericContext *ownerCtx,
                           const ValueDecl *ownerDecl) {
     if (!ownerCtx->isGenericContext())
@@ -2031,6 +2050,13 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
     }
 
     if (ownerCtx->getTrailingWhereClause()) {
+      // Ignore the where clause for AsyncSequence.flatMap from the
+      // _Concurrency module. This is an egregious hack to allow us to
+      // use overloading tricks to retain the behavior previously
+      // afforded by rethrowing conformances.
+      if (isAsyncSequenceFlatMap(ownerCtx))
+        return;
+
       forAllRequirementTypes(WhereClauseOwner(
                                const_cast<GenericContext *>(ownerCtx)),
                              [&](Type type, TypeRepr *typeRepr) {

stdlib/public/Concurrency/AsyncFlatMapSequence.swift

@@ -74,7 +74,6 @@ extension AsyncSequence {
   @preconcurrency 
   @_alwaysEmitIntoClient
   @inlinable
-  @available(SwiftStdlib 5.11, *)
   public __consuming func flatMap<SegmentOfResult: AsyncSequence>(
     _ transform: @Sendable @escaping (Element) async -> SegmentOfResult
   ) -> AsyncFlatMapSequence<Self, SegmentOfResult>
@@ -111,7 +110,6 @@ extension AsyncSequence {
   @preconcurrency 
   @_alwaysEmitIntoClient
   @inlinable
-  @available(SwiftStdlib 5.11, *)
   public __consuming func flatMap<SegmentOfResult: AsyncSequence>(
     _ transform: @Sendable @escaping (Element) async -> SegmentOfResult
   ) -> AsyncFlatMapSequence<Self, SegmentOfResult>
@@ -148,7 +146,6 @@ extension AsyncSequence {
   @preconcurrency 
   @_alwaysEmitIntoClient
   @inlinable
-  @available(SwiftStdlib 5.11, *)
   public __consuming func flatMap<SegmentOfResult: AsyncSequence>(
     _ transform: @Sendable @escaping (Element) async -> SegmentOfResult
   ) -> AsyncFlatMapSequence<Self, SegmentOfResult>

test/Concurrency/async_sequence_flatmap_overloading.swift

@@ -0,0 +1,21 @@
+// RUN: %target-swift-frontend -typecheck %s -verify
+
+// REQUIRES: concurrency
+
+@available(SwiftStdlib 5.1, *)
+struct MyAsyncSequence<Element>: AsyncSequence {
+  struct AsyncIterator: AsyncIteratorProtocol {
+    mutating func next() -> Element? { nil }
+  }
+
+  func makeAsyncIterator() -> AsyncIterator { .init() }
+}
+
+@available(SwiftStdlib 5.1, *)
+func testMe(ms: MyAsyncSequence<String>) {
+  let flatMS = ms.flatMap { string in
+    return MyAsyncSequence<[Character]>()
+  }
+
+  let _: AsyncFlatMapSequence<MyAsyncSequence<String>, MyAsyncSequence<[Character]>> = flatMS
+}