Treat non-loadable types as loadable in minimal resilience expansion

if package serialization (Package CMO) is enabled and use site is
in the same package in SIL verifier and builder. This allows non-loadable
types to be serialized when their defining modules are built resiliently.

Resolves rdar://127400743

Author: elsh

include/swift/SIL/SILBuilder.h

@@ -3067,7 +3067,21 @@ class SILBuilder {
     if (!SILModuleConventions(M).useLoweredAddresses())
       return true;
 
-    return getTypeLowering(Ty).isLoadable();
+    const auto &lowering = getTypeLowering(Ty);
+    if (lowering.isLoadable())
+      return true;
+
+    // Treat non-loadable as loadable in minimal resilience
+    // expansion if package serialization is enabled and the
+    // use site is in the same package.
+    auto tyMod = Ty.getASTType().getAnyNominal()->getModuleContext();
+    if (tyMod && tyMod->serializePackageEnabled() &&
+        tyMod->inSamePackage(M.getSwiftModule()) &&
+        lowering.getResilienceExpansion() == ResilienceExpansion::Minimal &&
+        lowering.isResilient())
+      return true;
+
+    return false;
   }
 
   void appendOperandTypeName(SILType OpdTy, llvm::SmallString<16> &Name) {

lib/AST/Decl.cpp

@@ -4275,7 +4275,7 @@ bool ValueDecl::bypassResilienceInPackage(ModuleDecl *accessingModule) const {
   // Client and the loaded module both need to be in the same package.
   // The loaded module needs to be built from source and opt in to allow
   // non-resilient access.
-  return getASTContext().LangOpts.EnableBypassResilienceInPackage &&
+  return accessingModule->getASTContext().LangOpts.EnableBypassResilienceInPackage &&
          getModuleContext()->inSamePackage(accessingModule) &&
          getModuleContext()->allowNonResilientAccess();
 }

lib/SIL/Verifier/SILVerifier.cpp

@@ -2553,7 +2553,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   void checkLoadInst(LoadInst *LI) {
     require(LI->getType().isObject(), "Result of load must be an object");
     require(!fnConv.useLoweredAddresses()
-                || LI->getType().isLoadable(*LI->getFunction()),
+                || LI->getType().isLoadable(*LI->getFunction())
+                || treatAsLoadableIfSerializedPackage(LI->getType(), *LI->getFunction()),
             "Load must have a loadable type");
     require(LI->getOperand()->getType().isAddress(),
             "Load operand must be an address");
@@ -2596,7 +2597,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
         "Inst with qualified ownership in a function that is not qualified");
     require(LBI->getType().isObject(), "Result of load must be an object");
     require(!fnConv.useLoweredAddresses()
-            || LBI->getType().isLoadable(*LBI->getFunction()),
+            || LBI->getType().isLoadable(*LBI->getFunction())
+            || treatAsLoadableIfSerializedPackage(LBI->getType(), *LBI->getFunction()),
             "Load must have a loadable type");
     require(LBI->getOperand()->getType().isAddress(),
             "Load operand must be an address");
@@ -2831,11 +2833,24 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     checkAccessEnforcement(I);
   }
 
+  bool treatAsLoadableIfSerializedPackage(SILType instType,
+                                          const SILFunction &instFunc) {
+    // This func should only be called if the passed type is not loadable.
+    assert(!instType.isLoadable(instFunc));
+    // Treat non-loadable as loadable in minimal resilience
+    // expansion if package serialization is enabled and the
+    // use site is in the same package.
+    return instFunc.getModule().getSwiftModule()->serializePackageEnabled() &&
+           M->inSamePackage(instFunc.getModule().getSwiftModule()) &&
+           instFunc.getResilienceExpansion() == ResilienceExpansion::Minimal;
+  }
+
   void checkStoreInst(StoreInst *SI) {
     require(SI->getSrc()->getType().isObject(),
             "Can't store from an address source");
     require(!fnConv.useLoweredAddresses()
-                || SI->getSrc()->getType().isLoadable(*SI->getFunction()),
+                || SI->getSrc()->getType().isLoadable(*SI->getFunction())
+                || treatAsLoadableIfSerializedPackage(SI->getSrc()->getType(), *SI->getFunction()),
             "Can't store a non loadable type");
     require(SI->getDest()->getType().isAddress(),
             "Must store to an address dest");
@@ -2881,7 +2896,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     require(SI->getSrc()->getType().isObject(),
             "Can't store from an address source");
     require(!fnConv.useLoweredAddresses()
-                || SI->getSrc()->getType().isLoadable(*SI->getFunction()),
+                || SI->getSrc()->getType().isLoadable(*SI->getFunction())
+                || treatAsLoadableIfSerializedPackage(SI->getSrc()->getType(), *SI->getFunction()),
             "Can't store a non loadable type");
     require(SI->getDest()->getType().isAddress(),
             "Must store to an address dest");

lib/SILOptimizer/IPO/CrossModuleOptimization.cpp

@@ -84,7 +84,7 @@ class CrossModuleOptimization {
 
   bool canSerializeGlobal(SILGlobalVariable *global);
 
-  bool canSerializeType(SILType type, TypeExpansionContext typeExpCtx);
+  bool canSerializeType(SILType type);
 
   bool canUseFromInline(DeclContext *declCtxt);
 
@@ -331,14 +331,12 @@ bool CrossModuleOptimization::canSerializeFunction(
 bool CrossModuleOptimization::canSerializeInstruction(
     SILInstruction *inst, FunctionFlags &canSerializeFlags, int maxDepth) {
   // First check if any result or operand types prevent serialization.
-  auto typeExpCtx = inst->getFunction()->getTypeExpansionContext();
-
   for (SILValue result : inst->getResults()) {
-    if (!canSerializeType(result->getType(), typeExpCtx))
+    if (!canSerializeType(result->getType()))
       return false;
   }
   for (Operand &op : inst->getAllOperands()) {
-    if (!canSerializeType(op.get()->getType(), typeExpCtx))
+    if (!canSerializeType(op.get()->getType()))
       return false;
   }
 
@@ -437,23 +435,11 @@ bool CrossModuleOptimization::canSerializeGlobal(SILGlobalVariable *global) {
   return true;
 }
 
-bool CrossModuleOptimization::canSerializeType(SILType type,
-                                               TypeExpansionContext typeExpCtx) {
+bool CrossModuleOptimization::canSerializeType(SILType type) {
   auto iter = typesChecked.find(type);
   if (iter != typesChecked.end())
     return iter->getSecond();
 
-  if (M.getSwiftModule()->isResilient()) {
-    auto minResilientCtx = TypeExpansionContext(ResilienceExpansion::Minimal,
-                                                typeExpCtx.getContext(),
-                                                typeExpCtx.isWholeModuleContext());
-    auto loadableInMinResilientCtx = M.Types.getTypeLowering(type, minResilientCtx).isLoadable();
-    if (!loadableInMinResilientCtx) {
-      typesChecked[type] = false;
-      return false;
-    }
-  }
-
   bool success = !type.getASTType().findIf(
     [this](Type rawSubType) {
       CanType subType = rawSubType->getCanonicalType();