AST: ModuleDecl::checkConformance() is a static method

Author: slavapestov

lib/AST/ConformanceLookup.cpp

@@ -796,7 +796,7 @@ bool TypeBase::isSendableType() {
   if (auto *fas = getAs<AnyFunctionType>())
     return fas->isSendable();
 
-  auto conformance = proto->getParentModule()->checkConformance(
+  auto conformance = ModuleDecl::checkConformance(
       this, proto, false /*allow missing*/);
   return conformance && !conformance.hasUnavailableConformance();
 }
@@ -849,7 +849,7 @@ static bool conformsToInvertible(CanType type, InvertibleProtocolKind ip) {
                     SILTokenType>()));
 
   const bool conforms =
-      (bool) proto->getParentModule()->checkConformance(
+      (bool) ModuleDecl::checkConformance(
           type, proto,
           /*allowMissing=*/false);
 

lib/AST/Decl.cpp

@@ -11635,9 +11635,7 @@ ActorIsolation::forActorInstanceParameter(Expr *actor,
     auto baseType =
         memberRef->getBase()->getType()->getMetatypeInstanceType();
     if (auto globalActor = ctx.getProtocol(KnownProtocolKind::GlobalActor)) {
-      auto *dc = declRef.getDecl()->getDeclContext();
-      auto *module = dc->getParentModule();
-      auto conformance = module->checkConformance(baseType, globalActor);
+      auto conformance = ModuleDecl::checkConformance(baseType, globalActor);
       if (conformance &&
           conformance.getWitnessByName(baseType, ctx.Id_shared) == declRef) {
         return ActorIsolation::forGlobalActor(baseType);

lib/AST/LifetimeDependence.cpp

@@ -175,20 +175,19 @@ static LifetimeDependenceKind getLifetimeDependenceKindFromDecl(
                                   : LifetimeDependenceKind::Inherit;
 }
 
-static bool isBitwiseCopyable(Type type, ModuleDecl *mod, ASTContext &ctx) {
+static bool isBitwiseCopyable(Type type, ASTContext &ctx) {
   auto *bitwiseCopyableProtocol =
       ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
   if (!bitwiseCopyableProtocol) {
     return false;
   }
-  return (bool)(mod->checkConformance(type, bitwiseCopyableProtocol));
+  return (bool)(ModuleDecl::checkConformance(type, bitwiseCopyableProtocol));
 }
 
 std::optional<LifetimeDependenceInfo>
 LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
   auto *dc = afd->getDeclContext();
   auto &ctx = dc->getASTContext();
-  auto *mod = afd->getModuleContext();
   auto &diags = ctx.Diags;
   auto capacity = afd->hasImplicitSelfDecl()
                       ? (afd->getParameters()->size() + 1)
@@ -216,7 +215,7 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
     bool isCompatible = true;
     // Lifetime dependence always propagates through temporary BitwiseCopyable
     // values, even if the dependence is scoped.
-    if (!isBitwiseCopyable(paramType, mod, ctx)) {
+    if (!isBitwiseCopyable(paramType, ctx)) {
       isCompatible = isLifetimeDependenceCompatibleWithOwnership(
         lifetimeKind, ownership, afd);
     }
@@ -416,7 +415,6 @@ std::optional<LifetimeDependenceInfo>
 LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
   auto *dc = afd->getDeclContext();
   auto &ctx = dc->getASTContext();
-  auto *mod = afd->getModuleContext();
 
   if (!ctx.LangOpts.hasFeature(Feature::NonescapableTypes)) {
     return std::nullopt;
@@ -450,7 +448,7 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
   if (!cd && afd->hasImplicitSelfDecl()) {
     Type selfTypeInContext = dc->getSelfTypeInContext();
     if (selfTypeInContext->isEscapable()) {
-      if (isBitwiseCopyable(selfTypeInContext, mod, ctx)) {
+      if (isBitwiseCopyable(selfTypeInContext, ctx)) {
           diags.diagnose(
               returnLoc,
               diag::lifetime_dependence_method_escapable_bitwisecopyable_self);
@@ -483,7 +481,7 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
     }
     auto paramOwnership = param->getValueOwnership();
     if (paramTypeInContext->isEscapable()) {
-      if (isBitwiseCopyable(paramTypeInContext, mod, ctx)) {
+      if (isBitwiseCopyable(paramTypeInContext, ctx)) {
         continue;
       }
       if (paramOwnership == ValueOwnership::Default) {

lib/IDE/ConformingMethodList.cpp

@@ -193,7 +193,7 @@ void ConformingMethodListCallbacks::getMatchingMethods(
 
       // The return type conforms to any of the requested protocols.
       for (auto Proto : ExpectedTypes) {
-        if (CurModule->checkConformance(resultTy, Proto))
+        if (ModuleDecl::checkConformance(resultTy, Proto))
           return true;
       }
 

lib/IRGen/GenArchetype.cpp

@@ -415,7 +415,7 @@ const TypeInfo *TypeConverter::convertArchetypeType(ArchetypeType *archetype) {
       IGM.getSwiftModule()->getASTContext().getProtocol(
           KnownProtocolKind::BitwiseCopyable);
   // The protocol won't be present in swiftinterfaces from older SDKs.
-  if (bitwiseCopyableProtocol && IGM.getSwiftModule()->checkConformance(
+  if (bitwiseCopyableProtocol && ModuleDecl::checkConformance(
                                      archetype, bitwiseCopyableProtocol)) {
     return BitwiseCopyableTypeInfo::create(storageType, abiAccessible);
   }

lib/IRGen/GenEnum.cpp

@@ -7324,8 +7324,8 @@ ResilientEnumImplStrategy::completeEnumTypeLayout(TypeConverter &TC,
       IGM.getSwiftModule()->getASTContext().getProtocol(
           KnownProtocolKind::BitwiseCopyable);
   if (bitwiseCopyableProtocol &&
-      IGM.getSwiftModule()->checkConformance(Type.getASTType(),
-                                             bitwiseCopyableProtocol)) {
+      ModuleDecl::checkConformance(Type.getASTType(),
+                                   bitwiseCopyableProtocol)) {
     return BitwiseCopyableTypeInfo::create(enumTy, abiAccessible);
   }
   return registerEnumTypeInfo(

lib/IRGen/GenStruct.cpp

@@ -1698,7 +1698,7 @@ const TypeInfo *TypeConverter::convertStructType(TypeBase *key, CanType type,
         IGM.getSwiftModule()->getASTContext().getProtocol(
             KnownProtocolKind::BitwiseCopyable);
     if (bitwiseCopyableProtocol &&
-        IGM.getSwiftModule()->checkConformance(type, bitwiseCopyableProtocol)) {
+        ModuleDecl::checkConformance(type, bitwiseCopyableProtocol)) {
       return BitwiseCopyableTypeInfo::create(IGM.OpaqueTy, structAccessible);
     }
     return &getResilientStructTypeInfo(copyable, structAccessible);

lib/IRGen/GenTuple.cpp

@@ -524,7 +524,7 @@ const TypeInfo *TypeConverter::convertTupleType(TupleType *tuple) {
     auto *bitwiseCopyableProtocol =
         IGM.getSwiftModule()->getASTContext().getProtocol(
             KnownProtocolKind::BitwiseCopyable);
-    if (bitwiseCopyableProtocol && IGM.getSwiftModule()->checkConformance(
+    if (bitwiseCopyableProtocol && ModuleDecl::checkConformance(
                                        tuple, bitwiseCopyableProtocol)) {
       return BitwiseCopyableTypeInfo::create(IGM.OpaqueTy, IsABIAccessible);
     }

lib/Refactoring/Async/AsyncHandlerDesc.cpp

@@ -17,10 +17,10 @@ using namespace swift;
 using namespace swift::refactoring::asyncrefactorings;
 
 /// Whether the given type is (or conforms to) the stdlib Error type
-static bool isErrorType(Type Ty, ModuleDecl *MD) {
+static bool isErrorType(Type Ty) {
   if (!Ty)
     return false;
-  return !MD->checkConformance(Ty, Ty->getASTContext().getErrorDecl())
+  return !ModuleDecl::checkConformance(Ty, Ty->getASTContext().getErrorDecl())
               .isInvalid();
 }
 
@@ -70,8 +70,7 @@ AsyncHandlerDesc AsyncHandlerDesc::get(const ValueDecl *Handler,
     HandlerDesc.Type = HandlerType::PARAMS;
     if (!HandlerParams.empty()) {
       auto LastParamTy = HandlerParams.back().getParameterType();
-      HandlerDesc.HasError = isErrorType(LastParamTy->getOptionalObjectType(),
-                                         Handler->getModuleContext());
+      HandlerDesc.HasError = isErrorType(LastParamTy->getOptionalObjectType());
     }
   }
 

lib/SIL/IR/AbstractionPattern.cpp

@@ -291,9 +291,9 @@ bool AbstractionPattern::conformsToKnownProtocol(
     = substTy->getASTContext().getProtocol(protocolKind);
 
   auto definitelyConforms = [&](CanType t) -> bool {
-    auto result = suppressible->getParentModule()
-      ->checkConformanceWithoutContext(t, suppressible,
-                                       /*allowMissing=*/false);
+    auto result =
+      ModuleDecl::checkConformanceWithoutContext(t, suppressible,
+                                                 /*allowMissing=*/false);
     return result.has_value() && !result.value().isInvalid();
   };