IRGen: We can't look through opaque archetypes if the underlying type contains a private type

Not without more context at least (where the substitution happens). The
private type could be from a different TU.

Yes, this can probably happen in earlier uses of opaque archetype
substitution. For now, fix the known failure.

rdar://56093964

Author: aschwaighofer

lib/IRGen/MetadataRequest.cpp

@@ -512,15 +512,28 @@ CanType IRGenModule::getRuntimeReifiedType(CanType type) {
   }));
 }
 
+static bool containsPrivateType(CanType ty) {
+  return ty.findIf([](Type t) -> bool {
+    if (auto *nominal = t->getAnyNominal()) {
+      if (nominal->getEffectiveAccess() <= AccessLevel::FilePrivate)
+        return true;
+    }
+    return false;
+  });
+}
+
 CanType IRGenModule::substOpaqueTypesWithUnderlyingTypes(CanType type) {
   // Substitute away opaque types whose underlying types we're allowed to
   // assume are constant.
   if (type->hasOpaqueArchetype()) {
     ReplaceOpaqueTypesWithUnderlyingTypes replacer(getSwiftModule(),
                                                   ResilienceExpansion::Maximal);
-    type = type.subst(replacer, replacer,
-                      SubstFlags::SubstituteOpaqueArchetypes)
-      ->getCanonicalType();
+    auto underlyingTy =
+        type.subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes)
+            ->getCanonicalType();
+    // The underlying type could contain a private type from a different TU.
+    if (!containsPrivateType(underlyingTy))
+      return underlyingTy;
   }
 
   return type;
@@ -533,8 +546,12 @@ SILType IRGenModule::substOpaqueTypesWithUnderlyingTypes(
   if (type.getASTType()->hasOpaqueArchetype()) {
     ReplaceOpaqueTypesWithUnderlyingTypes replacer(getSwiftModule(),
                                                   ResilienceExpansion::Maximal);
-    type = type.subst(getSILModule(), replacer, replacer, genericSig,
-                      /*substitute opaque*/ true);
+    auto underlyingTy =
+        type.subst(getSILModule(), replacer, replacer, genericSig,
+                   /*substitute opaque*/ true);
+    // The underlying type could contain a private type from a different TU.
+    if (!containsPrivateType(underlyingTy.getASTType()))
+      return underlyingTy;
   }
 
   return type;
@@ -548,11 +565,14 @@ IRGenModule::substOpaqueTypesWithUnderlyingTypes(CanType type,
   if (type->hasOpaqueArchetype()) {
     ReplaceOpaqueTypesWithUnderlyingTypes replacer(getSwiftModule(),
                                                   ResilienceExpansion::Maximal);
-    conformance = conformance.subst(type, replacer, replacer,
-                                    SubstFlags::SubstituteOpaqueArchetypes);
-    type = type.subst(replacer, replacer,
-                      SubstFlags::SubstituteOpaqueArchetypes)
-      ->getCanonicalType();
+    auto substConformance = conformance.subst(
+        type, replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes);
+    auto underlyingTy =
+        type.subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes)
+            ->getCanonicalType();
+    // The underlying type could contain a private type from a different TU.
+    if (!containsPrivateType(underlyingTy))
+      return std::make_pair(underlyingTy, substConformance);
   }
 
   return std::make_pair(type, conformance);

test/IRGen/Inputs/opaque_result_type_private_underlying_2.swift

@@ -0,0 +1,17 @@
+public protocol A {
+  associatedtype Assoc
+  func bindAssoc() -> Assoc
+}
+
+public protocol Q {}
+
+fileprivate struct PrivateS : Q {
+  init() {}
+}
+
+public struct G : A {
+  public init() {}
+   public func bindAssoc() -> some Q {
+     return PrivateS()
+   }
+}

test/IRGen/opaque_result_type_private_underlying.swift

@@ -0,0 +1,8 @@
+// RUN: %target-swift-frontend -disable-availability-checking -emit-ir -primary-file %s -primary-file %S/Inputs/opaque_result_type_private_underlying_2.swift
+
+public struct G2 : A {
+  public init() {}
+   public func bindAssoc() -> some Q {
+     return G().bindAssoc()
+   }
+}