Renamed type witnesses for the Async(Sequence|IteratorProtocol) Failure type

The type aliases for inferred type witnesses to the AsyncSequence and
AsyncIteratorProtocol's Failure associated type are getting in the way
of existing types with the same name. Therefore, when we create these
type aliases, given them weird names (e.g., `__AsyncSequence.Failure`) and
wire them up with `@_implements(<protocol>, Failure)` so that
associated type inference will find them.

This is probably a model we should move to in general, because it's odd
that we inject new declarations into types that could cause conflicts.
However, start by staging it in for just this one associated type
where we have source-compatibility concerns, and we can expand it over
time.

Fixes rdar://124362873.

Author: DougGregor

lib/Sema/AssociatedTypeInference.cpp

@@ -231,6 +231,17 @@ static bool containsConcreteDependentMemberType(Type ty) {
   });
 }
 
+/// Determine whether this is the AsyncIteratorProtocol.Failure or
+/// AsyncSequence.Failure associated type.
+static bool isAsyncIteratorOrSequenceFailure(AssociatedTypeDecl *assocType) {
+  auto proto = assocType->getProtocol();
+  if (!proto->isSpecificProtocol(KnownProtocolKind::AsyncIteratorProtocol) &&
+      !proto->isSpecificProtocol(KnownProtocolKind::AsyncSequence))
+    return false;
+
+  return assocType->getName() == assocType->getASTContext().Id_Failure;
+}
+
 static void recordTypeWitness(NormalProtocolConformance *conformance,
                               AssociatedTypeDecl *assocType,
                               Type type,
@@ -254,14 +265,40 @@ static void recordTypeWitness(NormalProtocolConformance *conformance,
 
   // If there was no type declaration, synthesize one.
   if (typeDecl == nullptr) {
+    Identifier name;
+    bool needsImplementsAttr;
+    if (isAsyncIteratorOrSequenceFailure(assocType)) {
+      // Use __<protocol>_<assocType> as the name, to keep it out of the
+      // way of other names.
+      llvm::SmallString<32> nameBuffer;
+      nameBuffer += "__";
+      nameBuffer += assocType->getProtocol()->getName().str();
+      nameBuffer += "_";
+      nameBuffer += assocType->getName().str();
+
+      name = ctx.getIdentifier(nameBuffer);
+      needsImplementsAttr = true;
+    } else {
+      // Declare a typealias with the same name as the associated type.
+      name = assocType->getName();
+      needsImplementsAttr = false;
+    }
+
     auto aliasDecl = new (ctx) TypeAliasDecl(
-        SourceLoc(), SourceLoc(), assocType->getName(), SourceLoc(),
+        SourceLoc(), SourceLoc(), name, SourceLoc(),
         /*genericparams*/ nullptr, dc);
     aliasDecl->setUnderlyingType(type);
 
     aliasDecl->setImplicit();
     aliasDecl->setSynthesized();
 
+    // If needed, add an @_implements(Protocol, Name) attribute.
+    if (needsImplementsAttr) {
+      auto attr = ImplementsAttr::create(
+          dc, assocType->getProtocol(), assocType->getName());
+      aliasDecl->getAttrs().add(attr);
+    }
+
     // Inject the typealias into the nominal decl that conforms to the protocol.
     auto nominal = dc->getSelfNominalTypeDecl();
     auto requiredAccessScope = evaluateOrDefault(
@@ -395,17 +432,6 @@ static bool isAsyncSequenceFailure(AssociatedTypeDecl *assocType) {
   return assocType->getName() == assocType->getASTContext().Id_Failure;
 }
 
-/// Determine whether this is the AsyncIteratorProtocol.Failure or
-/// AsyncSequence.Failure associated type.
-static bool isAsyncIteratorOrSequenceFailure(AssociatedTypeDecl *assocType) {
-  auto proto = assocType->getProtocol();
-  if (!proto->isSpecificProtocol(KnownProtocolKind::AsyncIteratorProtocol) &&
-      !proto->isSpecificProtocol(KnownProtocolKind::AsyncSequence))
-    return false;
-
-  return assocType->getName() == assocType->getASTContext().Id_Failure;
-}
-
 /// Attempt to resolve a type witness via member name lookup.
 static ResolveWitnessResult resolveTypeWitnessViaLookup(
                        NormalProtocolConformance *conformance,

test/ModuleInterface/async_sequence_conformance.swift

@@ -12,7 +12,8 @@ public struct SequenceAdapter<Base: AsyncSequence>: AsyncSequence {
   // CHECK: @available{{.*}}macOS 10.15
   // CHECK-NEXT: public typealias Element = Base.Element
   // CHECK: @available(
-  // CHECK-NEXT: public typealias Failure = Base.Failure
+  // CHECK: @_implements(_Concurrency.AsyncIteratorProtocol, Failure)
+  // CHECK-SAME: public typealias __AsyncIteratorProtocol_Failure = Base.Failure
   public typealias Element = Base.Element
 
   public struct AsyncIterator: AsyncIteratorProtocol {
@@ -23,7 +24,8 @@ public struct SequenceAdapter<Base: AsyncSequence>: AsyncSequence {
   public func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
 
   // CHECK: @available(
-  // CHECK-NEXT: public typealias Failure = Base.Failure
+  // CHECK: @_implements(_Concurrency.AsyncSequence, Failure)
+  // CHECK-SAME: public typealias __AsyncSequence_Failure = Base.Failure
 }
 
 // CHECK: @available(
@@ -37,7 +39,8 @@ public struct OtherSequenceAdapter<Base: AsyncSequence>: AsyncSequence {
   // CHECK-LABEL: public struct AsyncIterator
   // CHECK: @available{{.*}}macOS 10.15
   // CHECK: @available(
-  // CHECK-NEXT: public typealias Failure = Base.Failure
+  // CHECK: @_implements(_Concurrency.AsyncIteratorProtocol, Failure)
+  // CHECK-SAME: public typealias __AsyncIteratorProtocol_Failure = Base.Failure
   public typealias Element = Base.Element
 
   public struct Failure: Error { }