Improve @_implements for associated type witnesses

Allow `@_implements` to be expressed in an extension of the protocol in
which the associated type is defined. Use this to uncomment an
intended use of `@_implements` in `Sequence` that could be used to
replace a longstanding hack for associated type inference.

Since this change means that the standard library module interface
won't be accepted by older compilers, introduce a suppressible feature
ssociatedTypeImplements` that covers the use of `@_implements` on type
declarations. This will hide the `@_implements` attribute from older
compilers.

Author: DougGregor

include/swift/Basic/Features.def

@@ -169,6 +169,7 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(Extern, 0, "@_extern")
 LANGUAGE_FEATURE(ExpressionMacroDefaultArguments, 422, "Expression macro as caller-side default argument")
 LANGUAGE_FEATURE(BuiltinStoreRaw, 0, "Builtin.storeRaw")
 LANGUAGE_FEATURE(BuiltinCreateTask, 0, "Builtin.createTask and Builtin.createDiscardingTask")
+SUPPRESSIBLE_LANGUAGE_FEATURE(AssociatedTypeImplements, 0, "@_implements on associated types")
 
 // Swift 6
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)

lib/AST/ASTPrinter.cpp

@@ -3083,6 +3083,14 @@ static void suppressingFeatureIsolatedAny(PrintOptions &options,
   action();
 }
 
+static void suppressingFeatureAssociatedTypeImplements(PrintOptions &options,
+                                     llvm::function_ref<void()> action) {
+  unsigned originalExcludeAttrCount = options.ExcludeAttrList.size();
+  options.ExcludeAttrList.push_back(DeclAttrKind::Implements);
+  action();
+  options.ExcludeAttrList.resize(originalExcludeAttrCount);
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/AST/FeatureSet.cpp

@@ -342,6 +342,10 @@ static bool usesFeatureExtern(Decl *decl) {
   return decl->getAttrs().hasAttribute<ExternAttr>();
 }
 
+static bool usesFeatureAssociatedTypeImplements(Decl *decl) {
+  return isa<TypeDecl>(decl) && decl->getAttrs().hasAttribute<ImplementsAttr>();
+}
+
 static bool usesFeatureExpressionMacroDefaultArguments(Decl *decl) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
     for (auto param : *func->getParameters()) {

lib/Sema/TypeCheckAttr.cpp

@@ -3886,7 +3886,7 @@ void AttributeChecker::visitImplementsAttr(ImplementsAttr *attr) {
   // conforms to the specified protocol.
   NominalTypeDecl *NTD = DC->getSelfNominalTypeDecl();
   if (auto *OtherPD = dyn_cast<ProtocolDecl>(NTD)) {
-    if (!OtherPD->inheritsFrom(PD) &&
+    if (!(OtherPD == PD || OtherPD->inheritsFrom(PD)) &&
         !(OtherPD->isSpecificProtocol(KnownProtocolKind::DistributedActor) ||
           PD->isSpecificProtocol(KnownProtocolKind::Actor))) {
       diagnose(attr->getLocation(),

stdlib/public/Distributed/DistributedActor.swift

@@ -448,4 +448,4 @@ public protocol _DistributedActorStub where Self: DistributedActor {}
 @available(SwiftStdlib 6.0, *)
 public func _distributedStubFatalError(function: String = #function) -> Never {
   fatalError("Unexpected invocation of distributed method '\(function)' stub!")
-}
+}

stdlib/public/core/Sequence.swift

@@ -453,7 +453,7 @@ public protocol Sequence<Element> {
 // Provides a default associated type witness for Iterator when the
 // Self type is both a Sequence and an Iterator.
 extension Sequence where Self: IteratorProtocol {
-  // @_implements(Sequence, Iterator)
+  @_implements(Sequence, Iterator)
   public typealias _Default_Iterator = Self
 }
 

test/ModuleInterface/async_sequence_conformance.swift

@@ -4,16 +4,21 @@
 
 // REQUIRES: concurrency, OS=macosx
 
-// CHECK: @available(
-// CHECK-NEXT: public struct SequenceAdapte
+// CHECK: public struct SequenceAdapte
 @available(SwiftStdlib 5.1, *)
 public struct SequenceAdapter<Base: AsyncSequence>: AsyncSequence {
   // CHECK-LABEL: public struct AsyncIterator
   // CHECK: @available{{.*}}macOS 10.15
   // CHECK-NEXT: public typealias Element = Base.Element
+
+  // CHECK: #if compiler(>=5.3) && $AssociatedTypeImplements
   // CHECK: @available(
   // CHECK: @_implements(_Concurrency.AsyncIteratorProtocol, Failure)
   // CHECK-SAME: public typealias __AsyncIteratorProtocol_Failure = Base.Failure
+  // CHECK-NEXT: #else
+  // CHECK-NOT: @_implements
+  // CHECK: public typealias __AsyncIteratorProtocol_Failure = Base.Failure
+  // CHECK-NEXT: #endif
   public typealias Element = Base.Element
 
   public struct AsyncIterator: AsyncIteratorProtocol {
@@ -28,8 +33,7 @@ public struct SequenceAdapter<Base: AsyncSequence>: AsyncSequence {
   // CHECK-SAME: public typealias __AsyncSequence_Failure = Base.Failure
 }
 
-// CHECK: @available(
-// CHECK-NEXT: public struct OtherSequenceAdapte
+// CHECK: public struct OtherSequenceAdapte
 @available(SwiftStdlib 5.1, *)
 public struct OtherSequenceAdapter<Base: AsyncSequence>: AsyncSequence {
   // CHECK: public typealias Element = Base.Element