[Serialization] Add recovery for structs with non-loadable constraints

That is, if a struct's generic requirements can't be deserialized,
drop the struct. This is the same logic that's already in play for
enums and (as of the previous commit) classes, so it should be pretty
well tested by now. (Hence the sole test I'm adding here, snuck into
superclass.swift because it's a superclass /constraint/ being tested.)

I don't know of any outstanding issues caused by this, but it was
weird to have it for enums and classes but not structs, so here we
are.

Author: jrose-apple

include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,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 = 492; // dependency types for classes
+const uint16_t SWIFTMODULE_VERSION_MINOR = 493; // dependency types for structs
 
 using DeclIDField = BCFixed<31>;
 
@@ -948,7 +948,8 @@ namespace decls_block {
     GenericEnvironmentIDField, // generic environment
     AccessLevelField,       // access level
     BCVBR<4>,               // number of conformances
-    BCArray<TypeIDField>    // inherited types
+    BCVBR<4>,               // number of inherited types
+    BCArray<TypeIDField>    // inherited types, followed by dependency types
     // Trailed by the generic parameters (if any), the members record, and
     // finally conformance info (if any).
   >;

lib/Serialization/Deserialization.cpp

@@ -2488,14 +2488,25 @@ class swift::DeclDeserializer {
     bool isObjC;
     GenericEnvironmentID genericEnvID;
     uint8_t rawAccessLevel;
-    unsigned numConformances;
-    ArrayRef<uint64_t> rawInheritedIDs;
+    unsigned numConformances, numInheritedTypes;
+    ArrayRef<uint64_t> rawInheritedAndDependencyIDs;
 
     decls_block::StructLayout::readRecord(scratch, nameID, contextID,
                                           isImplicit, isObjC, genericEnvID,
                                           rawAccessLevel,
-                                          numConformances,
-                                          rawInheritedIDs);
+                                          numConformances, numInheritedTypes,
+                                          rawInheritedAndDependencyIDs);
+
+    Identifier name = MF.getIdentifier(nameID);
+
+    for (TypeID dependencyID :
+           rawInheritedAndDependencyIDs.slice(numInheritedTypes)) {
+      auto dependency = MF.getTypeChecked(dependencyID);
+      if (!dependency) {
+        return llvm::make_error<TypeError>(
+            name, takeErrorInfo(dependency.takeError()));
+      }
+    }
 
     auto DC = MF.getDeclContext(contextID);
     if (declOrOffset.isComplete())
@@ -2505,10 +2516,8 @@ class swift::DeclDeserializer {
     if (declOrOffset.isComplete())
       return declOrOffset;
 
-    auto theStruct = MF.createDecl<StructDecl>(SourceLoc(),
-                                               MF.getIdentifier(nameID),
-                                               SourceLoc(), None, genericParams,
-                                               DC);
+    auto theStruct = MF.createDecl<StructDecl>(SourceLoc(), name, SourceLoc(),
+                                               None, genericParams, DC);
     declOrOffset = theStruct;
 
     // Read the generic environment.
@@ -2528,7 +2537,8 @@ class swift::DeclDeserializer {
 
     theStruct->computeType();
 
-    handleInherited(theStruct, rawInheritedIDs);
+    handleInherited(theStruct,
+                    rawInheritedAndDependencyIDs.slice(0, numInheritedTypes));
 
     theStruct->setMemberLoader(&MF, MF.DeclTypeCursor.GetCurrentBitNo());
     skipRecord(MF.DeclTypeCursor, decls_block::MEMBERS);

lib/Serialization/Serialization.cpp

@@ -3145,12 +3145,20 @@ void Serializer::writeDecl(const Decl *D) {
     auto conformances = theStruct->getLocalConformances(
                           ConformanceLookupKind::All, nullptr);
 
-    SmallVector<TypeID, 4> inheritedTypes;
+    SmallVector<TypeID, 4> inheritedAndDependencyTypes;
     for (auto inherited : theStruct->getInherited()) {
       assert(!inherited.getType()->hasArchetype());
-      inheritedTypes.push_back(addTypeRef(inherited.getType()));
+      inheritedAndDependencyTypes.push_back(addTypeRef(inherited.getType()));
     }
 
+    llvm::SmallSetVector<Type, 4> dependencyTypes;
+    for (Requirement req : theStruct->getGenericRequirements()) {
+      collectDependenciesFromRequirement(dependencyTypes, req,
+                                         /*excluding*/nullptr);
+    }
+    for (Type ty : dependencyTypes)
+      inheritedAndDependencyTypes.push_back(addTypeRef(ty));
+
     uint8_t rawAccessLevel =
       getRawStableAccessLevel(theStruct->getFormalAccess());
 
@@ -3164,7 +3172,8 @@ void Serializer::writeDecl(const Decl *D) {
                                             theStruct->getGenericEnvironment()),
                              rawAccessLevel,
                              conformances.size(),
-                             inheritedTypes);
+                             theStruct->getInherited().size(),
+                             inheritedAndDependencyTypes);
 
 
     writeGenericParams(theStruct->getGenericParams());

test/Serialization/Recovery/superclass.swift

@@ -30,9 +30,13 @@ public class A1_Sub: DisappearingSuperclass {}
 // CHECK-RECOVERY-NOT: class A2_Grandchild
 public class A2_Grandchild: A1_Sub {}
 
-// CHECK-LABEL: class B_ConstrainedGeneric<T> where T : DisappearingSuperclass {
-// CHECK-RECOVERY-NOT: class B_ConstrainedGeneric
-public class B_ConstrainedGeneric<T> where T: DisappearingSuperclass {}
+// CHECK-LABEL: class B1_ConstrainedGeneric<T> where T : DisappearingSuperclass {
+// CHECK-RECOVERY-NOT: class B1_ConstrainedGeneric
+public class B1_ConstrainedGeneric<T> where T: DisappearingSuperclass {}
+
+// CHECK-LABEL: struct B2_ConstrainedGeneric<T> where T : DisappearingSuperclass {
+// CHECK-RECOVERY-NOT: struct B2_ConstrainedGeneric
+public struct B2_ConstrainedGeneric<T> where T: DisappearingSuperclass {}
 
 // CHECK-ALWAYS-LABEL: class C1_GenericBase<T> {
 public class C1_GenericBase<T> {}