ModuleInterface: Avoid attempting to print protocols inherited from superclasses.

"Extra" protocols from a superclass are already handled when printing the superclass, so we should not accumulate them when recording protocols for a subclass.

Resolves rdar://98523784

Author: tshortli

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -388,8 +388,12 @@ class InheritedProtocolCollector {
   /// For each type in \p directlyInherited, classify the protocols it refers to
   /// as included for printing or not, and record them in the appropriate
   /// vectors.
+  ///
+  /// If \p skipExtra is true then avoid recording any extra protocols to
+  /// print, such as synthesized conformances or conformances to non-public
+  /// protocols.
   void recordProtocols(ArrayRef<InheritedEntry> directlyInherited,
-                       const Decl *D, bool skipSynthesized = false) {
+                       const Decl *D, bool skipExtra = false) {
     Optional<AvailableAttrList> availableAttrs;
 
     for (InheritedEntry inherited : directlyInherited) {
@@ -398,6 +402,9 @@ class InheritedProtocolCollector {
         continue;
 
       bool canPrintNormally = canPrintProtocolTypeNormally(inheritedTy, D);
+      if (!canPrintNormally && skipExtra)
+        continue;
+
       ExistentialLayout layout = inheritedTy->getExistentialLayout();
       for (ProtocolDecl *protoDecl : layout.getProtocols()) {
         if (canPrintNormally)
@@ -411,7 +418,7 @@ class InheritedProtocolCollector {
       // any of those besides 'AnyObject'.
     }
 
-    if (skipSynthesized)
+    if (skipExtra)
       return;
 
     // Check for synthesized protocols, like Hashable on enums.
@@ -493,11 +500,12 @@ class InheritedProtocolCollector {
     if (auto *CD = dyn_cast<ClassDecl>(D)) {
       for (auto *SD = CD->getSuperclassDecl(); SD;
            SD = SD->getSuperclassDecl()) {
-        map[nominal].recordProtocols(
-            SD->getInherited(), SD, /*skipSynthesized=*/true);
+        map[nominal].recordProtocols(SD->getInherited(), SD,
+                                     /*skipExtra=*/true);
         for (auto *Ext: SD->getExtensions()) {
           if (shouldInclude(Ext)) {
-            map[nominal].recordProtocols(Ext->getInherited(), Ext);
+            map[nominal].recordProtocols(Ext->getInherited(), Ext,
+                                         /*skipExtra=*/true);
           }
         }
       }

test/ModuleInterface/skip-redundant-conformances.swift

@@ -1,10 +1,25 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-emit-module-interface(%t/Foo.swiftinterface) %s -module-name Foo
 // RUN: %target-swift-typecheck-module-from-interface(%t/Foo.swiftinterface) -module-name Foo
+// RUN: %FileCheck %s < %t/Foo.swiftinterface
 
-public protocol ProtocolA : class {}
+// CHECK: public protocol ProtocolA : AnyObject
+public protocol ProtocolA : AnyObject {}
+// CHECK: public protocol ProtocolB : Foo.ProtocolA
 public protocol ProtocolB: ProtocolA {}
+// CHECK-NOT: ProtocolC
 protocol ProtocolC: ProtocolA {}
 
+// CHECK: @_hasMissingDesignatedInitializers public class A : Foo.ProtocolB
 public class A: ProtocolB {}
+// CHECK: @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class B : Foo.A
 public class B: A, ProtocolC {}
+
+// CHECK: @_hasMissingDesignatedInitializers public class C
+public class C {}
+extension C: ProtocolC {}
+// CHECK: @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers public class D : Foo.C
+public class D: C {}
+
+// CHECK: extension Foo.C : Foo.ProtocolA {}
+// CHECK-NOT: extension Foo.D : Foo.ProtocolA {}