Eliminate remaining dependencies on a single underlying opaque type

The first generic parameter of an `OpaqueTypeDecl` was still being used
as the "underlying" interface type of the opaque type, which is
incorrect for both structural and named opaque result types. Eliminate
this notion, because the (declared) interface type already has the
correct structure.

Only ABI checking depended on the old "underlying" type, so rework it to
instead substitute into properly for structural opaque result types as
well.

Deserialization required a small adjustment to eliminate a cycle
because the interface type of an `OpaqueTypeDecl` involves opaque
archetype types, which reference the declaration itself... so
deserialize the interface type later, now that it's correct.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2719,9 +2719,6 @@ class OpaqueTypeDecl final :
   /// abstracted underlying types.
   GenericSignature OpaqueInterfaceGenericSignature;
 
-  /// The underlying type, which will involve the opaque generic parameters.
-  Type UnderlyingInterfaceType;
-  
   /// If known, the underlying type and conformances of the opaque type,
   /// expressed as a SubstitutionMap for the opaque interface generic signature.
   /// This maps types in the interface generic signature to the outer generic
@@ -2733,8 +2730,7 @@ class OpaqueTypeDecl final :
   OpaqueTypeDecl(ValueDecl *NamingDecl, GenericParamList *GenericParams,
                  DeclContext *DC,
                  GenericSignature OpaqueInterfaceGenericSignature,
-                 ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs,
-                 Type UnderlyingInterfaceType);
+                 ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs);
 
   unsigned getNumOpaqueReturnTypeReprs() const {
     return NamingDeclAndHasOpaqueReturnTypeRepr.getInt()
@@ -2751,8 +2747,7 @@ class OpaqueTypeDecl final :
       ValueDecl *NamingDecl, GenericParamList *GenericParams,
       DeclContext *DC,
       GenericSignature OpaqueInterfaceGenericSignature,
-      ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs,
-      Type UnderlyingInterfaceType);
+      ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs);
 
   ValueDecl *getNamingDecl() const {
     return NamingDeclAndHasOpaqueReturnTypeRepr.getPointer();
@@ -2793,11 +2788,8 @@ class OpaqueTypeDecl final :
     };
   }
 
-  /// The underlying interface type describing the whole opaque type.
-  Type getUnderlyingInterfaceType() const {
-    return UnderlyingInterfaceType;
-  }
-  
+  /// The substitutions that map the generic parameters of the opaque type to
+  /// their underlying types, when that information is known.
   Optional<SubstitutionMap> getUnderlyingTypeSubstitutions() const {
     return UnderlyingTypeSubstitutions;
   }

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -1510,18 +1510,18 @@ SDKNode *swift::ide::api::
 SwiftDeclCollector::constructTypeNode(Type T, TypeInitInfo Info) {
   if (Ctx.checkingABI()) {
     T = T->getCanonicalType();
-    // If the type is a opaque result type (some Type) and we're in the ABI mode,
-    // we should substitute the opaque result type to its underlying type.
-    // Notice this only works if the opaque result type is from an inlinable
-    // function where the function body is present in the swift module file, thus
-    // allowing us to know the concrete type.
-    if (auto OTA = T->getAs<OpaqueTypeArchetypeType>()) {
-      if (auto *D = OTA->getDecl()) {
-        if (auto SubMap = D->getUnderlyingTypeSubstitutions()) {
-          T = D->getUnderlyingInterfaceType().
-            subst(*SubMap)->getCanonicalType();
-        }
-      }
+
+    if (T->hasOpaqueArchetype()) {
+      // When the type contains an opaque result type and we're in the ABI mode,
+      // we should substitute the opaque result type to its underlying type.
+      // Notice this only works if the opaque result type is from an inlinable
+      // function where the function body is present in the swift module file,
+      // thus allowing us to know the concrete type.
+      ReplaceOpaqueTypesWithUnderlyingTypes replacer(
+          /*inContext=*/nullptr, ResilienceExpansion::Maximal,
+          /*isWholeModuleContext=*/false);
+      T = T.subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes)
+          ->getCanonicalType();
     }
   }
 

lib/AST/ASTDumper.cpp

@@ -567,7 +567,7 @@ namespace {
       OS << " naming_decl=";
       printDeclName(OTD->getNamingDecl());
       PrintWithColorRAII(OS, TypeColor) << " opaque_interface="
-        << OTD->getUnderlyingInterfaceType().getString();
+        << OTD->getDeclaredInterfaceType().getString();
       OS << " in "
          << OTD->getOpaqueInterfaceGenericSignature()->getAsString();
       if (auto underlyingSubs = OTD->getUnderlyingTypeSubstitutions()) {

lib/AST/Decl.cpp

@@ -7781,14 +7781,12 @@ OpaqueTypeDecl::OpaqueTypeDecl(ValueDecl *NamingDecl,
                                GenericParamList *GenericParams, DeclContext *DC,
                                GenericSignature OpaqueInterfaceGenericSignature,
                                ArrayRef<OpaqueReturnTypeRepr *>
-                                   OpaqueReturnTypeReprs,
-                               Type UnderlyingInterfaceType)
+                                   OpaqueReturnTypeReprs)
     : GenericTypeDecl(DeclKind::OpaqueType, DC, Identifier(), SourceLoc(), {},
                       GenericParams),
       NamingDeclAndHasOpaqueReturnTypeRepr(
         NamingDecl, !OpaqueReturnTypeReprs.empty()),
-      OpaqueInterfaceGenericSignature(OpaqueInterfaceGenericSignature),
-      UnderlyingInterfaceType(UnderlyingInterfaceType) {
+      OpaqueInterfaceGenericSignature(OpaqueInterfaceGenericSignature) {
   // Always implicit.
   setImplicit();
 
@@ -7806,15 +7804,14 @@ OpaqueTypeDecl *OpaqueTypeDecl::get(
       ValueDecl *NamingDecl, GenericParamList *GenericParams,
       DeclContext *DC,
       GenericSignature OpaqueInterfaceGenericSignature,
-      ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs,
-      Type UnderlyingInterfaceType) {
+      ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs) {
   ASTContext &ctx = DC->getASTContext();
   auto size = totalSizeToAlloc<OpaqueReturnTypeRepr *>(
       OpaqueReturnTypeReprs.size());
   auto mem = ctx.Allocate(size, alignof(OpaqueTypeDecl));
   return new (mem) OpaqueTypeDecl(
       NamingDecl, GenericParams, DC, OpaqueInterfaceGenericSignature,
-      OpaqueReturnTypeReprs, UnderlyingInterfaceType);
+      OpaqueReturnTypeReprs);
 }
 
 bool OpaqueTypeDecl::isOpaqueReturnTypeOfFunction(

lib/AST/Type.cpp

@@ -3323,8 +3323,9 @@ getArchetypeAndRootOpaqueArchetype(Type maybeOpaqueType) {
 OpaqueSubstitutionKind
 ReplaceOpaqueTypesWithUnderlyingTypes::shouldPerformSubstitution(
     OpaqueTypeDecl *opaque) const {
-  return shouldPerformSubstitution(opaque, inContext->getParentModule(),
-                                   contextExpansion);
+  auto inModule = inContext ? inContext->getParentModule()
+                            : opaque->getParentModule();
+  return shouldPerformSubstitution(opaque, inModule, contextExpansion);
 }
 OpaqueSubstitutionKind
 ReplaceOpaqueTypesWithUnderlyingTypes::shouldPerformSubstitution(
@@ -3459,7 +3460,8 @@ operator()(SubstitutableType *maybeOpaqueType) const {
   // context.
   auto inContext = this->inContext;
   auto isContextWholeModule = this->isContextWholeModule;
-  if (partialSubstTy.findIf(
+  if (inContext &&
+      partialSubstTy.findIf(
           [inContext, substitutionKind, isContextWholeModule](Type t) -> bool {
             if (!canSubstituteTypeInto(t, inContext, substitutionKind,
                                        isContextWholeModule))
@@ -3515,6 +3517,7 @@ operator()(CanType maybeOpaqueType, Type replacementType,
     // SIL type lowering may have already substituted away the opaque type, in
     // which case we'll end up "substituting" the same type.
     if (maybeOpaqueType->isEqual(replacementType)) {
+      assert(inContext && "Need context for already-substituted opaque types");
       return inContext->getParentModule()
                       ->lookupConformance(replacementType, protocol);
     }

lib/Sema/TypeCheckGeneric.cpp

@@ -183,12 +183,6 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
   auto originatingGenericContext = originatingDecl->getAsGenericContext();
   GenericParamList *genericParams;
   GenericSignature interfaceSignature;
-
-  // FIXME: The generic parameter that serves as the underlying type of the
-  // opaque result type. This should become unnecessary, once we have fully
-  // implemented structural opaque result types.
-  GenericTypeParamType *underlyingGenericParamType;
-
   CollectedOpaqueReprs opaqueReprs;
   if (auto namedOpaque = dyn_cast<NamedOpaqueReturnTypeRepr>(repr)) {
     // Produce the generic signature for the opaque type.
@@ -211,8 +205,6 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
       // Already produced an error.
       return nullptr;
     }
-
-    underlyingGenericParamType = interfaceSignature.getGenericParams()[0];
   } else {
     opaqueReprs = collectOpaqueReturnTypeReprs(repr);
     SmallVector<GenericTypeParamType *, 2> genericParamTypes;
@@ -285,13 +277,12 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
     genericParams = originatingGenericContext
         ? originatingGenericContext->getGenericParams()
         : nullptr;
-    underlyingGenericParamType = genericParamTypes[0];
   }
 
   // Create the OpaqueTypeDecl for the result type.
   auto opaqueDecl = OpaqueTypeDecl::get(
-      originatingDecl, genericParams, parentDC, interfaceSignature, opaqueReprs,
-      underlyingGenericParamType);
+      originatingDecl, genericParams, parentDC, interfaceSignature,
+      opaqueReprs);
   opaqueDecl->copyFormalAccessFrom(originatingDecl);
   if (auto originatingSig = originatingDC->getGenericSignatureOfContext()) {
     opaqueDecl->setGenericSignature(originatingSig);

lib/Serialization/Deserialization.cpp

@@ -3457,7 +3457,6 @@ class DeclDeserializer {
 
     auto declContext = MF.getDeclContext(contextID);
     auto interfaceSig = MF.getGenericSignature(interfaceSigID);
-    auto interfaceType = MF.getType(interfaceTypeID);
 
     // Check for reentrancy.
     if (declOrOffset.isComplete())
@@ -3468,13 +3467,13 @@ class DeclDeserializer {
     // Create the decl.
     auto opaqueDecl = OpaqueTypeDecl::get(
         /*NamingDecl=*/ nullptr, genericParams, declContext,
-        interfaceSig, /*OpaqueReturnTypeReprs*/ { },
-        interfaceType);
+        interfaceSig, /*OpaqueReturnTypeReprs*/ { });
     declOrOffset = opaqueDecl;
 
     auto namingDecl = cast<ValueDecl>(MF.getDecl(namingDeclID));
     opaqueDecl->setNamingDecl(namingDecl);
 
+    auto interfaceType = MF.getType(interfaceTypeID);
     opaqueDecl->setInterfaceType(MetatypeType::get(interfaceType));
 
     if (auto accessLevel = getActualAccessLevel(rawAccessLevel))

lib/Serialization/Serialization.cpp

@@ -3820,21 +3820,20 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     auto contextID = S.addDeclContextRef(opaqueDecl->getDeclContext());
     auto interfaceSigID = S.addGenericSignatureRef(
         opaqueDecl->getOpaqueInterfaceGenericSignature());
-    auto interfaceTypeID =
-      S.addTypeRef(opaqueDecl->getUnderlyingInterfaceType());
+    auto interfaceTypeID = S.addTypeRef(opaqueDecl->getDeclaredInterfaceType());
 
     auto genericSigID = S.addGenericSignatureRef(opaqueDecl->getGenericSignature());
 
-    SubstitutionMapID underlyingTypeID = 0;
+    SubstitutionMapID underlyingSubsID = 0;
     if (auto underlying = opaqueDecl->getUnderlyingTypeSubstitutions())
-      underlyingTypeID = S.addSubstitutionMapRef(*underlying);
+      underlyingSubsID = S.addSubstitutionMapRef(*underlying);
     uint8_t rawAccessLevel =
       getRawStableAccessLevel(opaqueDecl->getFormalAccess());
     unsigned abbrCode = S.DeclTypeAbbrCodes[OpaqueTypeLayout::Code];
     OpaqueTypeLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
                                  contextID.getOpaqueValue(), namingDeclID,
                                  interfaceSigID, interfaceTypeID, genericSigID,
-                                 underlyingTypeID, rawAccessLevel);
+                                 underlyingSubsID, rawAccessLevel);
     writeGenericParams(opaqueDecl->getGenericParams());
   }
 

test/api-digester/Inputs/cake_baseline/cake.swift

@@ -211,8 +211,8 @@ public class Zoo {
   }
   @inlinable
   @available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
-  public func getCurrentAnimalInlinable() -> some Animal {
-    return Cat()
+  public func getCurrentAnimalInlinable() -> [some Animal] {
+    return [Cat()]
   }
 }
 

test/api-digester/Inputs/cake_current/cake.swift

@@ -224,8 +224,8 @@ public class Zoo {
   }
   @inlinable
   @available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
-  public func getCurrentAnimalInlinable() -> some Animal {
-    return Dog()
+  public func getCurrentAnimalInlinable() -> [some Animal] {
+    return [Dog()]
   }
 }