Fix opaque type substitution in the package cmo resilience domain

We need to serialize the underlying type if we want to see the
underlying type accross the package resilience domain.

rdar://128482863

Author: aschwaighofer

include/swift/AST/Types.h

@@ -6621,6 +6621,8 @@ enum class OpaqueSubstitutionKind {
   // Can be done if the underlying type is accessible from the context we
   // substitute into. Private types cannot be accessed from a different TU.
   SubstituteSameModuleMaximalResilience,
+  // Same as previous but with package and above visibility.
+  SubstituteSamePackageMaximalResilience,
   // Substitute in a different module from the opaque defining decl. Can only
   // be done if the underlying type is public.
   SubstituteNonResilientModule

lib/AST/Decl.cpp

@@ -10078,6 +10078,11 @@ bool OpaqueTypeDecl::exportUnderlyingType() const {
   if (mod->getResilienceStrategy() != ResilienceStrategy::Resilient)
     return true;
 
+  // If we perform package CMO, in-package clients must have access to the
+  // underlying type.
+  if (mod->serializePackageEnabled())
+    return true;
+
   ValueDecl *namingDecl = getNamingDecl();
   if (auto *AFD = dyn_cast<AbstractFunctionDecl>(namingDecl))
     return AFD->getResilienceExpansion() == ResilienceExpansion::Minimal;

lib/AST/TypeSubstitution.cpp

@@ -982,6 +982,14 @@ ReplaceOpaqueTypesWithUnderlyingTypes::shouldPerformSubstitution(
       module == contextModule)
     return OpaqueSubstitutionKind::SubstituteSameModuleMaximalResilience;
 
+  // Allow replacement of opaque result types in the context of maximal
+  // resilient expansion if the context's and the opaque type's module are in
+  // the same package.
+  if (contextExpansion == ResilienceExpansion::Maximal &&
+      module->isResilient() && module->serializePackageEnabled() &&
+      module->inSamePackage(contextModule))
+    return OpaqueSubstitutionKind::SubstituteSamePackageMaximalResilience;
+
   // Allow general replacement from non resilient modules. Otherwise, disallow.
   if (module->isResilient())
     return OpaqueSubstitutionKind::DontSubstitute;
@@ -1047,6 +1055,10 @@ static bool canSubstituteTypeInto(Type ty, const DeclContext *dc,
 
     return typeDecl->getEffectiveAccess() > AccessLevel::FilePrivate;
 
+  case OpaqueSubstitutionKind::SubstituteSamePackageMaximalResilience: {
+    return typeDecl->getEffectiveAccess() >= AccessLevel::Package;
+  }
+
   case OpaqueSubstitutionKind::SubstituteNonResilientModule:
     // Can't access types that are not public from a different module.
     if (dc->getParentModule() == typeDecl->getDeclContext()->getParentModule() &&

test/SILOptimizer/package-cmo-resilient-mode.swift

@@ -26,6 +26,7 @@
 
 // RUN: %target-build-swift -module-name=Main -package-name Pkg -I%t -emit-sil -O %t/main.swift -o %t/Main-res.sil
 // RUN: %FileCheck %s --check-prefixes=CHECK-MAIN-COMMON,CHECK-MAIN-RES < %t/Main-res.sil
+// RUN: %FileCheck %s --check-prefixes=CHECK-OPAQUE < %t/Main-res.sil
 
 // RUN: llvm-bcanalyzer --dump %t/Lib.swiftmodule | %FileCheck %s --check-prefix=CHECK-BC
 // CHECK-BC: SERIALIZE_PACKAGE_ENABLED
@@ -188,6 +189,20 @@ public func mainPubArgRetInlinable(_ arg: PubKlass) -> PubStruct {
   return PubStruct(arg.data)
 }
 
+// CHECK-OPAQUE: sil @$s4Main023testPackageInSerializedC4FuncyyF : $@convention(thin) () -> ()
+// CHECK-OPAQUE: struct $Thing
+// CHECK-OPAQUE: struct $Thing1
+// CHECK-OPAQUE: function_ref @$s3Lib13getSomeProto2QryF
+// CHECK-OPAQUE: function_ref @$s3Lib13getSomeProto3QryF
+// CHECK-OPAQUE: } // end sil function '$s4Main023testPackageInSerializedC4FuncyyF'
+
+public func testPackageInSerializedPackageFunc() {
+    print(getSomeProto())
+    print(getSomeProto1())
+    print(getSomeProto2())
+    print(getSomeProto3())
+}
+
 //--- Lib.swift
 
 public struct PubStruct {
@@ -504,3 +519,24 @@ public func reproduce(_ e: Something) {
     return e.f()
   }
 }
+
+public protocol SomeProto {}
+
+public struct Thing : SomeProto {}
+package struct Thing1 : SomeProto {}
+internal struct Thing2 : SomeProto {}
+private struct Thing3 : SomeProto {}
+
+// Don't crash on this example.
+public func getSomeProto() -> some SomeProto {
+    return Thing()
+}
+public func getSomeProto1() -> some SomeProto {
+    return Thing1()
+}
+public func getSomeProto2() -> some SomeProto {
+    return Thing2()
+}
+public func getSomeProto3() -> some SomeProto {
+    return Thing3()
+}