Serialization: Serialize ProtocolDecl::getSuperclassDecl() instead of ProtocolDecl::getSuperclass()

Protocols with a superclass bound written as `protocol P where Self: C`
return null from getSuperclass(). Unqualified lookup only cares about
getSuperclassDecl(), so serialize that instead.

Fixes rdar://problem/124478687.

Author: slavapestov

lib/Serialization/Deserialization.cpp

@@ -4480,14 +4480,14 @@ class DeclDeserializer {
     IdentifierID nameID;
     DeclContextID contextID;
     bool isImplicit, isClassBounded, isObjC, hasSelfOrAssocTypeRequirements;
-    TypeID superclassID;
+    DeclID superclassDeclID;
     uint8_t rawAccessLevel;
     ArrayRef<uint64_t> dependencyIDs;
 
     decls_block::ProtocolLayout::readRecord(scratch, nameID, contextID,
                                             isImplicit, isClassBounded, isObjC,
                                             hasSelfOrAssocTypeRequirements,
-                                            superclassID,
+                                            superclassDeclID,
                                             rawAccessLevel,
                                             dependencyIDs);
 
@@ -4512,8 +4512,10 @@ class DeclDeserializer {
         /*TrailingWhere=*/nullptr);
     declOrOffset = proto;
 
-    proto->setSuperclass(MF.getType(superclassID));
+    auto *superclassDecl = dyn_cast_or_null<ClassDecl>(MF.getDecl(superclassDeclID));
 
+    ctx.evaluator.cacheOutput(SuperclassDeclRequest{proto},
+                              std::move(superclassDecl));
     ctx.evaluator.cacheOutput(ProtocolRequiresClassRequest{proto},
                               std::move(isClassBounded));
     ctx.evaluator.cacheOutput(HasSelfOrAssociatedTypeRequirementsRequest{proto},

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 865; // removal of noncopyable generics control block
+const uint16_t SWIFTMODULE_VERSION_MINOR = 866; // protocol superclass fix
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1535,7 +1535,7 @@ namespace decls_block {
     BCFixed<1>,             // class-bounded?
     BCFixed<1>,             // objc?
     BCFixed<1>,             // existential-type-supported?
-    TypeIDField,            // superclass
+    DeclIDField,            // superclass decl
     AccessLevelField,       // access level
     BCArray<TypeIDField>    // dependency types
     // Trailed by the inherited protocols, the generic parameters (if any),

lib/Serialization/Serialization.cpp

@@ -4353,7 +4353,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
                                  ->requiresClass(),
                                proto->isObjC(),
                                proto->hasSelfOrAssociatedTypeRequirements(),
-                               S.addTypeRef(proto->getSuperclass()),
+                               S.addDeclRef(proto->getSuperclassDecl()),
                                rawAccessLevel,
                                dependencyTypeIDs);
 

test/Serialization/Inputs/class-bound-protocol.swift

@@ -1,15 +1,39 @@
-public protocol P: C {}
+//
 
-public class C: P {
+public protocol Base {}
+
+extension Base {
+  public func funcInBaseProtocol() {}
+}
+
+//
+
+public class C: Base {
   public init() {}
   public func funcInClass() {}
 }
 
-public protocol GenericP: GenericC<Int> {}
+//
+
+public protocol P1: C {}
+
+public protocol P2 where Self: C {}
 
-public class GenericC<T> {
+public class D: C, P1, P2 {}
+
+//
+
+public class GenericC<T>: Base {
   public init() {}
   public func funcInClass() {}
 }
 
-extension GenericC: GenericP where T == Int {}
+//
+
+public protocol GenericP1: GenericC<Int> {}
+
+public protocol GenericP2 where Self: GenericC<Int> {}
+
+public class GenericD<T>: GenericC<T> {}
+
+extension GenericD: GenericP1, GenericP2 where T == Int {}

test/Serialization/use-class-bound-protocol.swift

@@ -6,9 +6,19 @@
 import ClassBoundProtocol
 
 func f() {
-  let p: P = C()
-  p.funcInClass()
+  let p1: any P1 = D()
+  p1.funcInClass()
+  p1.funcInBaseProtocol()
 
-  let genericP: GenericP = GenericC<Int>()
-  genericP.funcInClass()
+  let p2: any P2 = D()
+  p2.funcInClass()
+  p2.funcInBaseProtocol()
+
+  let genericP1: any GenericP1 = GenericD<Int>()
+  genericP1.funcInClass()
+  genericP1.funcInBaseProtocol()
+
+  let genericP2: any GenericP2 = GenericD<Int>()
+  genericP2.funcInClass()
+  genericP2.funcInBaseProtocol()
 }