Fix (de-)serialization of opaque result types for structural opaque types.

Serialize the ordinal value of OpaqueTypeArchetypeTypes and properly
set the interface type of OpaqueTypeDecl on deserialization.

Author: DougGregor

lib/Serialization/Deserialization.cpp

@@ -3447,58 +3447,50 @@ class DeclDeserializer {
     GenericSignatureID interfaceSigID;
     TypeID interfaceTypeID;
     GenericSignatureID genericSigID;
-    SubstitutionMapID underlyingTypeID;
+    SubstitutionMapID underlyingTypeSubsID;
     uint8_t rawAccessLevel;
     decls_block::OpaqueTypeLayout::readRecord(scratch, contextID,
                                               namingDeclID, interfaceSigID,
                                               interfaceTypeID, genericSigID,
-                                              underlyingTypeID, rawAccessLevel);
+                                              underlyingTypeSubsID,
+                                              rawAccessLevel);
 
     auto declContext = MF.getDeclContext(contextID);
     auto interfaceSig = MF.getGenericSignature(interfaceSigID);
-    auto interfaceType = MF.getType(interfaceTypeID)
-                            ->castTo<GenericTypeParamType>();
+    auto interfaceType = MF.getType(interfaceTypeID);
 
     // Check for reentrancy.
     if (declOrOffset.isComplete())
       return cast<OpaqueTypeDecl>(declOrOffset.get());
-      
+
+    auto genericParams = MF.maybeReadGenericParams(declContext);
+
     // Create the decl.
     auto opaqueDecl = OpaqueTypeDecl::get(
-        /*NamingDecl*/ nullptr, /*GenericParams*/ nullptr, declContext,
-        interfaceSig, /*OpaqueReturnTypeReprs*/ { }, interfaceType);
+        /*NamingDecl=*/ nullptr, genericParams, declContext,
+        interfaceSig, /*OpaqueReturnTypeReprs*/ { },
+        interfaceType->castTo<GenericTypeParamType>());
     declOrOffset = opaqueDecl;
 
     auto namingDecl = cast<ValueDecl>(MF.getDecl(namingDeclID));
     opaqueDecl->setNamingDecl(namingDecl);
 
+    opaqueDecl->setInterfaceType(MetatypeType::get(interfaceType));
+
     if (auto accessLevel = getActualAccessLevel(rawAccessLevel))
       opaqueDecl->setAccess(*accessLevel);
     else
       MF.fatal();
 
-    if (auto genericParams = MF.maybeReadGenericParams(opaqueDecl)) {
-      ctx.evaluator.cacheOutput(GenericParamListRequest{opaqueDecl},
-                                std::move(genericParams));
-    }
-
     auto genericSig = MF.getGenericSignature(genericSigID);
     if (genericSig)
       opaqueDecl->setGenericSignature(genericSig);
-    if (underlyingTypeID) {
-      auto subMapOrError = MF.getSubstitutionMapChecked(underlyingTypeID);
+    if (underlyingTypeSubsID) {
+      auto subMapOrError = MF.getSubstitutionMapChecked(underlyingTypeSubsID);
       if (!subMapOrError)
         return subMapOrError.takeError();
       opaqueDecl->setUnderlyingTypeSubstitutions(subMapOrError.get());
     }
-    SubstitutionMap subs;
-    if (genericSig) {
-      subs = genericSig->getIdentitySubstitutionMap();
-    }
-    // TODO [OPAQUE SUPPORT]: multiple opaque types
-    auto opaqueTy = OpaqueTypeArchetypeType::get(opaqueDecl, 0, subs);
-    auto metatype = MetatypeType::get(opaqueTy);
-    opaqueDecl->setInterfaceType(metatype);
     return opaqueDecl;
   }
 
@@ -5522,9 +5514,10 @@ class TypeDeserializer {
   Expected<Type> deserializeOpaqueArchetypeType(ArrayRef<uint64_t> scratch,
                                                 StringRef blobData) {
     DeclID opaqueDeclID;
+    unsigned ordinal;
     SubstitutionMapID subsID;
-    decls_block::OpaqueArchetypeTypeLayout::readRecord(scratch,
-                                                       opaqueDeclID, subsID);
+    decls_block::OpaqueArchetypeTypeLayout::readRecord(
+        scratch, opaqueDeclID, ordinal, subsID);
 
     auto opaqueTypeOrError = MF.getDeclChecked(opaqueDeclID);
     if (!opaqueTypeOrError)
@@ -5535,9 +5528,7 @@ class TypeDeserializer {
     if (!subsOrError)
       return subsOrError.takeError();
 
-    // TODO [OPAQUE SUPPORT]: to support multiple opaque types we will probably
-    // have to serialize the ordinal, which is always 0 for now
-    return OpaqueTypeArchetypeType::get(opaqueDecl, 0, subsOrError.get());
+    return OpaqueTypeArchetypeType::get(opaqueDecl, ordinal, subsOrError.get());
   }
 
   Expected<Type> deserializeNestedArchetypeType(ArrayRef<uint64_t> scratch,

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,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 = 653; // `IsDistributed` bit on SILFunction
+const uint16_t SWIFTMODULE_VERSION_MINOR = 654; // opaque result type orinal
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1083,6 +1083,7 @@ namespace decls_block {
   using OpaqueArchetypeTypeLayout = BCRecordLayout<
     OPAQUE_ARCHETYPE_TYPE,
     DeclIDField,           // the opaque type decl
+    BCVBR<4>,              // the ordinal
     SubstitutionMapIDField // the arguments
   >;
 

lib/Serialization/Serialization.cpp

@@ -4485,7 +4485,8 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
     auto substMapID = S.addSubstitutionMapRef(archetypeTy->getSubstitutions());
     unsigned abbrCode = S.DeclTypeAbbrCodes[OpaqueArchetypeTypeLayout::Code];
     OpaqueArchetypeTypeLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
-                                          declID, substMapID);
+                                          declID, archetypeTy->getOrdinal(),
+                                          substMapID);
   }
 
   void visitNestedArchetypeType(const NestedArchetypeType *archetypeTy) {