Make opaque type archetypes root- and nested-type agnostic

Author: DougGregor

include/swift/AST/Types.h

@@ -5547,10 +5547,12 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
 
 public:
   /// Get an opaque archetype representing the underlying type of the given
-  /// opaque type decl's opaque param with ordinal `ordinal`. For example, in
-  /// `(some P, some Q)`, `some P`'s type param would have ordinal 0 and `some
-  /// Q`'s type param would have ordinal 1.
-  static Type get(OpaqueTypeDecl *decl, unsigned ordinal, SubstitutionMap subs);
+  /// opaque type decl's interface type. For example, in
+  /// `(some P, some Q)`, `some P`'s interface type would be the generic
+  /// parameter with index 0, and `some Q`'s interface type would be the
+  /// generic parameter with index 1.
+  static Type get(OpaqueTypeDecl *decl, Type interfaceType,
+                  SubstitutionMap subs);
 
   /// Retrieve the opaque type declaration.
   OpaqueTypeDecl *getDecl() const;

lib/AST/ASTContext.cpp

@@ -4244,7 +4244,7 @@ OpaqueTypeArchetypeType *OpaqueTypeArchetypeType::getNew(
 }
 
 Type OpaqueTypeArchetypeType::get(
-    OpaqueTypeDecl *Decl, unsigned ordinal, SubstitutionMap Substitutions) {
+    OpaqueTypeDecl *Decl, Type interfaceType, SubstitutionMap Substitutions) {
   // TODO: We could attempt to preserve type sugar in the substitution map.
   // Currently archetypes are assumed to be always canonical in many places,
   // though, so doing so would require fixing those places.
@@ -4265,8 +4265,7 @@ Type OpaqueTypeArchetypeType::get(
     environments[{Decl, Substitutions}] = env;
   }
 
-  auto opaqueParamType = Decl->getOpaqueGenericParams()[ordinal];
-  return env->getOrCreateArchetypeFromInterfaceType(opaqueParamType);
+  return env->getOrCreateArchetypeFromInterfaceType(interfaceType);
 }
 
 CanOpenedArchetypeType OpenedArchetypeType::get(Type existential,

lib/AST/ASTDemangler.cpp

@@ -274,7 +274,8 @@ Type ASTBuilder::resolveOpaqueType(NodePointer opaqueDescriptor,
     SubstitutionMap subs = createSubstitutionMapFromGenericArgs(
         opaqueDecl->getGenericSignature(), allArgs,
         LookUpConformanceInModule(parentModule));
-    return OpaqueTypeArchetypeType::get(opaqueDecl, ordinal, subs);
+    Type interfaceType = opaqueDecl->getOpaqueGenericParams()[ordinal];
+    return OpaqueTypeArchetypeType::get(opaqueDecl, interfaceType, subs);
   }
 
   // TODO: named opaque types

lib/AST/Type.cpp

@@ -4922,7 +4922,8 @@ case TypeKind::Id:
          return newSubs[index];
        },
        LookUpConformanceInModule(opaque->getDecl()->getModuleContext()));
-    return OpaqueTypeArchetypeType::get(opaque->getDecl(), opaque->getOrdinal(),
+    return OpaqueTypeArchetypeType::get(opaque->getDecl(),
+                                        opaque->getInterfaceType(),
                                         newSubMap);
   }
   case TypeKind::NestedArchetype: {

lib/Sema/TypeCheckType.cpp

@@ -295,7 +295,8 @@ static Type getIdentityOpaqueTypeArchetypeType(
   if (outerGenericSignature)
     subs = outerGenericSignature->getIdentitySubstitutionMap();
 
-  return OpaqueTypeArchetypeType::get(opaqueDecl, ordinal, subs);
+  Type interfaceType = opaqueDecl->getOpaqueGenericParams()[ordinal];
+  return OpaqueTypeArchetypeType::get(opaqueDecl, interfaceType, subs);
 }
 
 Type TypeResolution::resolveTypeInContext(TypeDecl *typeDecl,
@@ -2127,7 +2128,7 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
             subs = outerGenericSignature->getIdentitySubstitutionMap();
 
           return OpaqueTypeArchetypeType::get(
-                            opaqueDecl, gpDecl->getIndex(), subs);
+              opaqueDecl, gpDecl->getDeclaredInterfaceType(), subs);
         }
       }
 

lib/Serialization/Deserialization.cpp

@@ -5513,21 +5513,26 @@ class TypeDeserializer {
   Expected<Type> deserializeOpaqueArchetypeType(ArrayRef<uint64_t> scratch,
                                                 StringRef blobData) {
     DeclID opaqueDeclID;
-    unsigned ordinal;
+    TypeID interfaceTypeID;
     SubstitutionMapID subsID;
     decls_block::OpaqueArchetypeTypeLayout::readRecord(
-        scratch, opaqueDeclID, ordinal, subsID);
+        scratch, opaqueDeclID, interfaceTypeID, subsID);
 
     auto opaqueTypeOrError = MF.getDeclChecked(opaqueDeclID);
     if (!opaqueTypeOrError)
       return opaqueTypeOrError.takeError();
 
+    auto interfaceTypeOrError = MF.getTypeChecked(interfaceTypeID);
+    if (!interfaceTypeOrError)
+      return interfaceTypeOrError.takeError();
+
     auto opaqueDecl = cast<OpaqueTypeDecl>(opaqueTypeOrError.get());
     auto subsOrError = MF.getSubstitutionMapChecked(subsID);
     if (!subsOrError)
       return subsOrError.takeError();
 
-    return OpaqueTypeArchetypeType::get(opaqueDecl, ordinal, subsOrError.get());
+    return OpaqueTypeArchetypeType::get(
+        opaqueDecl, interfaceTypeOrError.get(), 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 = 656; // enable explicit existentials
+const uint16_t SWIFTMODULE_VERSION_MINOR = 657; // opaque interface type
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1084,7 +1084,7 @@ namespace decls_block {
   using OpaqueArchetypeTypeLayout = BCRecordLayout<
     OPAQUE_ARCHETYPE_TYPE,
     DeclIDField,           // the opaque type decl
-    BCVBR<4>,              // the ordinal
+    TypeIDField,           // the interface type
     SubstitutionMapIDField // the arguments
   >;
 

lib/Serialization/Serialization.cpp

@@ -4482,11 +4482,11 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
   visitOpaqueTypeArchetypeType(const OpaqueTypeArchetypeType *archetypeTy) {
     using namespace decls_block;
     auto declID = S.addDeclRef(archetypeTy->getDecl());
+    auto interfaceTypeID = S.addTypeRef(archetypeTy->getInterfaceType());
     auto substMapID = S.addSubstitutionMapRef(archetypeTy->getSubstitutions());
     unsigned abbrCode = S.DeclTypeAbbrCodes[OpaqueArchetypeTypeLayout::Code];
     OpaqueArchetypeTypeLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
-                                          declID, archetypeTy->getOrdinal(),
-                                          substMapID);
+                                          declID, interfaceTypeID, substMapID);
   }
 
   void visitNestedArchetypeType(const NestedArchetypeType *archetypeTy) {