Cherry pick #24443 into 'tensorflow' to fix Xcode builds. (#24763)

Author: rxwei

include/swift/AST/Types.h

@@ -4983,10 +4983,11 @@ END_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)
 /// to their underlying types.
 class ReplaceOpaqueTypesWithUnderlyingTypes {
 public:
-  SILFunction *context;
-  ReplaceOpaqueTypesWithUnderlyingTypes(
-      SILFunction *context)
-      : context(context) {}
+  ModuleDecl *contextModule;
+  ResilienceExpansion contextExpansion;
+  ReplaceOpaqueTypesWithUnderlyingTypes(ModuleDecl *contextModule,
+                                        ResilienceExpansion contextExpansion)
+      : contextModule(contextModule), contextExpansion(contextExpansion) {}
 
   /// TypeSubstitutionFn
   Type operator()(SubstitutableType *maybeOpaqueType) const;
@@ -4999,7 +5000,8 @@ class ReplaceOpaqueTypesWithUnderlyingTypes {
   bool shouldPerformSubstitution(OpaqueTypeDecl *opaque) const;
 
   static bool shouldPerformSubstitution(OpaqueTypeDecl *opaque,
-                                        SILFunction *context);
+                                        ModuleDecl *contextModule,
+                                        ResilienceExpansion contextExpansion);
 };
 
 /// An archetype that represents the dynamic type of an opened existential.

lib/AST/Type.cpp

@@ -2474,12 +2474,36 @@ getArchetypeAndRootOpaqueArchetype(Type maybeOpaqueType) {
 
 bool ReplaceOpaqueTypesWithUnderlyingTypes::shouldPerformSubstitution(
     OpaqueTypeDecl *opaque) const {
-  return shouldPerformSubstitution(opaque, context);
+  return shouldPerformSubstitution(opaque, contextModule, contextExpansion);
 }
 
-static Type substOpaqueTypesWithUnderlyingTypes(
-    Type ty, SILFunction *context) {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(context);
+bool ReplaceOpaqueTypesWithUnderlyingTypes::shouldPerformSubstitution(
+    OpaqueTypeDecl *opaque, ModuleDecl *contextModule,
+    ResilienceExpansion contextExpansion) {
+  auto namingDecl = opaque->getNamingDecl();
+
+  // Allow replacement of opaque result types of inlineable function regardless
+  // of resilience and in which context.
+  if (namingDecl->getAttrs().hasAttribute<InlinableAttr>()) {
+    return true;
+  }
+  // Allow replacement of opaque result types in the context of maximal
+  // resilient expansion if the context's and the opaque type's module are the
+  // same.
+  auto module = namingDecl->getModuleContext();
+  if (contextExpansion == ResilienceExpansion::Maximal &&
+      module == contextModule)
+    return true;
+
+  // Allow general replacement from non resilient modules. Otherwise, disallow.
+  return !module->isResilient();
+}
+
+static Type
+substOpaqueTypesWithUnderlyingTypes(Type ty, ModuleDecl *contextModule,
+                                    ResilienceExpansion contextExpansion) {
+  ReplaceOpaqueTypesWithUnderlyingTypes replacer(contextModule,
+                                                 contextExpansion);
   return ty.subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes);
 }
 
@@ -2512,15 +2536,18 @@ operator()(SubstitutableType *maybeOpaqueType) const {
 
   // If the type still contains opaque types, recur.
   if (substTy->hasOpaqueArchetype()) {
-    return substOpaqueTypesWithUnderlyingTypes(substTy, context);
+    return substOpaqueTypesWithUnderlyingTypes(substTy, contextModule,
+                                               contextExpansion);
   }
   return substTy;
 }
 
 static ProtocolConformanceRef
 substOpaqueTypesWithUnderlyingTypes(ProtocolConformanceRef ref, Type origType,
-                                    SILFunction *context) {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(context);
+                                    ModuleDecl *contextModule,
+                                    ResilienceExpansion contextExpansion) {
+  ReplaceOpaqueTypesWithUnderlyingTypes replacer(contextModule,
+                                                 contextExpansion);
   return ref.subst(origType, replacer, replacer,
                    SubstFlags::SubstituteOpaqueArchetypes);
 }
@@ -2562,7 +2589,8 @@ operator()(CanType maybeOpaqueType, Type replacementType,
 
   // If the type still contains opaque types, recur.
   if (substTy->hasOpaqueArchetype()) {
-    return substOpaqueTypesWithUnderlyingTypes(substRef, substTy, context);
+    return substOpaqueTypesWithUnderlyingTypes(substRef, substTy, contextModule,
+                                               contextExpansion);
   }
   return substRef;
 }

lib/SIL/SILFunctionType.cpp

@@ -3002,7 +3002,9 @@ static bool areABICompatibleParamsOrReturns(SILType a, SILType b,
     // Opaque types are compatible with their substitution.
     if (inFunction) {
       auto opaqueTypesSubsituted = aa;
-      ReplaceOpaqueTypesWithUnderlyingTypes replacer(inFunction);
+      ReplaceOpaqueTypesWithUnderlyingTypes replacer(
+          inFunction->getModule().getSwiftModule(),
+          inFunction->getResilienceExpansion());
       if (aa.getASTType()->hasOpaqueArchetype())
         opaqueTypesSubsituted = aa.subst(inFunction->getModule(), replacer,
                                          replacer, CanGenericSignature(), true);

lib/SIL/SILType.cpp

@@ -592,28 +592,6 @@ bool SILType::isLoweringOf(SILModule &Mod, CanType formalType) {
   return loweredType.getASTType() == formalType;
 }
 
-bool ReplaceOpaqueTypesWithUnderlyingTypes::shouldPerformSubstitution(
-    OpaqueTypeDecl *opaque, SILFunction *context) {
-  auto namingDecl = opaque->getNamingDecl();
-
-  // Allow replacement of opaque result types of inlineable function regardless
-  // of resilience and in which context.
-  if (namingDecl->getAttrs().hasAttribute<InlinableAttr>()) {
-    return true;
-  }
-  // Allow replacement of opaque result types in the context of maximal
-  // resilient expansion if the context's and the opaque type's module are the
-  // same.
-  auto expansion = context->getResilienceExpansion();
-  auto module = namingDecl->getModuleContext();
-  if (expansion == ResilienceExpansion::Maximal &&
-      module == context->getModule().getSwiftModule())
-    return true;
-
-  // Allow general replacement from non resilient modules. Otherwise, disallow.
-  return !module->isResilient();
-}
-
 // SWIFT_ENABLE_TENSORFLOW
 /// Returns true if this SILType is a differentiable type.
 bool SILType::isDifferentiable(SILModule &M) const {

lib/SILOptimizer/Transforms/SpecializeOpaqueArchetypes.cpp

@@ -28,13 +28,15 @@ using namespace swift;
 
 static Type substOpaqueTypesWithUnderlyingTypes(
     Type ty, SILFunction *context) {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(context);
+  ReplaceOpaqueTypesWithUnderlyingTypes replacer(
+      context->getModule().getSwiftModule(), context->getResilienceExpansion());
   return ty.subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes);
 }
 
 static SubstitutionMap
 substOpaqueTypesWithUnderlyingTypes(SubstitutionMap map, SILFunction *context) {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(context);
+  ReplaceOpaqueTypesWithUnderlyingTypes replacer(
+      context->getModule().getSwiftModule(), context->getResilienceExpansion());
   return map.subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes);
 }
 
@@ -292,7 +294,9 @@ class OpaqueSpecializerCloner
       return Sty;
 
    // Apply the opaque types substitution.
-    ReplaceOpaqueTypesWithUnderlyingTypes replacer(&Original);
+    ReplaceOpaqueTypesWithUnderlyingTypes replacer(
+        Original.getModule().getSwiftModule(),
+        Original.getResilienceExpansion());
     Sty = Ty.subst(Original.getModule(), replacer, replacer,
                    CanGenericSignature(), true);
     return Sty;
@@ -307,7 +311,9 @@ class OpaqueSpecializerCloner
   ProtocolConformanceRef remapConformance(Type type,
                                           ProtocolConformanceRef conf) {
     // Apply the opaque types substitution.
-    ReplaceOpaqueTypesWithUnderlyingTypes replacer(&Original);
+    ReplaceOpaqueTypesWithUnderlyingTypes replacer(
+        Original.getModule().getSwiftModule(),
+        Original.getResilienceExpansion());
     return conf.subst(type, replacer, replacer,
                       SubstFlags::SubstituteOpaqueArchetypes);
   }
@@ -434,7 +440,9 @@ class OpaqueArchetypeSpecializer : public SILFunctionTransform {
         if (auto opaqueTy = type->getAs<OpaqueTypeArchetypeType>()) {
           auto opaque = opaqueTy->getDecl();
           return ReplaceOpaqueTypesWithUnderlyingTypes::
-              shouldPerformSubstitution(opaque, context);
+              shouldPerformSubstitution(opaque,
+                                        context->getModule().getSwiftModule(),
+                                        context->getResilienceExpansion());
         }
         return false;
       });