[Distributed] Avoid redundant conformance to DistributedActor in interface files

Forgetting to handle DistributedActor next to Actor strikes again:
Actors are special that their conformance is implicit and needs not be
printed in swift interface files.

an actor's Actor conformance was filtered out, however the same logic
needs to be applied to DistributedActor, as otherwise there can be
redundant conformance errors when validating module interface files.

Resolves rdar://160252579

Author: ktoso

lib/AST/ProtocolConformance.cpp

@@ -1267,7 +1267,7 @@ void NominalTypeDecl::prepareConformanceTable() const {
     }
   }
 
-  // Actor classes conform to the actor protocol.
+  // Actor classes conform to the appropriate actor protocol.
   if (auto classDecl = dyn_cast<ClassDecl>(mutableThis)) {
     if (classDecl->isDistributedActor()) {
       addSynthesized(ctx.getProtocol(KnownProtocolKind::DistributedActor));

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -688,10 +688,13 @@ class InheritedProtocolCollector {
     if (!printOptions.shouldPrint(nominal))
       return;
 
-    /// is this nominal specifically an 'actor'?
+    /// is this nominal specifically an 'actor' or 'distributed actor'?
     bool actorClass = false;
-    if (auto klass = dyn_cast<ClassDecl>(nominal))
+    bool distributedActorClass = false;
+    if (auto klass = dyn_cast<ClassDecl>(nominal)) {
       actorClass = klass->isActor();
+      distributedActorClass = klass->isDistributedActor();
+    }
 
     SmallPtrSet<ProtocolDecl *, 16> handledProtocols;
 
@@ -727,7 +730,10 @@ class InheritedProtocolCollector {
         // it is only valid to conform to Actor on an 'actor' decl,
         // not extensions of that 'actor'.
         if (actorClass &&
-            inherited->isSpecificProtocol(KnownProtocolKind::Actor))
+          inherited->isSpecificProtocol(KnownProtocolKind::Actor))
+          return TypeWalker::Action::SkipNode;
+        if (distributedActorClass &&
+          inherited->isSpecificProtocol(KnownProtocolKind::DistributedActor))
           return TypeWalker::Action::SkipNode;
 
         // Do not synthesize an extension to print a conformance to an

test/ModuleInterface/distributed_no_redundant_conformance.swift

@@ -0,0 +1,26 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-emit-module-interface(%t/TestResilient.swiftinterface) %s -module-name TestResilient
+// RUN: %target-swift-typecheck-module-from-interface(%t/TestResilient.swiftinterface) -module-name TestResilient
+// RUN: %FileCheck %s --dump-input=always < %t/TestResilient.swiftinterface
+
+// RUN: %target-swift-frontend -compile-module-from-interface -swift-version 5 %t/TestResilient.swiftinterface -o %t/TestResilient.swiftmodule
+// RUN: %target-swift-frontend -emit-module -o /dev/null -merge-modules -swift-version 5  -emit-module-interface-path - %t/TestResilient.swiftmodule -module-name TestResilient | %FileCheck %s
+
+import Distributed
+
+// Note that tat while an actor is implicitly conforming to Actor, we don't need to print this in interfaces
+// as it would cause 'redundant conformance of ... to (Distributed)Actor' issues.
+
+public actor Example {}
+
+// CHECK-NOT: extension TestResilient.Example : _Concurrency.Actor {}
+
+public distributed actor DistributedExample {
+  public typealias ActorSystem = LocalTestingDistributedActorSystem
+  distributed func example() {}
+}
+
+// CHECK: distributed public actor DistributedExample {
+
+// CHECK-NOT: extension TestResilient.DistributedExample : Distributed.DistributedActor {}