AST: Clean up isSendableType()

Author: slavapestov

include/swift/AST/ActorIsolation.h

@@ -39,9 +39,6 @@ class AbstractClosureExpr;
 /// to avoid having to include Types.h.
 bool areTypesEqual(Type type1, Type type2);
 
-/// Determine whether the given type is suitable as a concurrent value type.
-bool isSendableType(ModuleDecl *module, Type type);
-
 /// Determines if the 'let' can be read from anywhere within the given module,
 /// regardless of the isolation or async-ness of the context in which
 /// the var is read.

include/swift/AST/Types.h

@@ -925,11 +925,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Determines whether this type is an any actor type.
   bool isAnyActorType();
 
-  /// Returns true if this type is a Sendable type.
-  bool isSendableType(DeclContext *declContext);
-
-  /// Returns true if this type is a Sendable type.
-  bool isSendableType(ModuleDecl *parentModule);
+  /// Returns true if this type conforms to Sendable, or if its a function type
+  /// that is @Sendable.
+  bool isSendableType();
 
   /// Determines whether this type conforms or inherits (if it's a protocol
   /// type) from `DistributedActor`.

include/swift/SIL/SILType.h

@@ -891,9 +891,6 @@ class SILType {
   /// Returns true if this function conforms to the Sendable protocol.
   bool isSendable(SILFunction *fn) const;
 
-  ProtocolConformanceRef conformsToProtocol(SILFunction *fn,
-                                            ProtocolDecl *protocol) const;
-
   /// False if SILValues of this type cannot be used outside the scope of their
   /// lifetime dependence.
   bool isEscapable() const;

lib/AST/Type.cpp

@@ -580,12 +580,28 @@ bool TypeBase::isAnyActorType() {
   return false;
 }
 
-bool TypeBase::isSendableType(DeclContext *ctx) {
-  return isSendableType(ctx->getParentModule());
-}
+bool TypeBase::isSendableType() {
+  auto proto = getASTContext().getProtocol(KnownProtocolKind::Sendable);
+  if (!proto)
+    return true;
+
+  // First check if we have a function type. If we do, check if it is
+  // Sendable. We do this since functions cannot conform to protocols.
+  if (auto *fas = getAs<SILFunctionType>())
+    return fas->isSendable();
+  if (auto *fas = getAs<AnyFunctionType>())
+    return fas->isSendable();
 
-bool TypeBase::isSendableType(ModuleDecl *parentModule) {
-  return ::isSendableType(parentModule, Type(this));
+  auto conformance = proto->getParentModule()->checkConformance(this, proto);
+  if (conformance.isInvalid())
+    return false;
+
+  // Look for missing Sendable conformances.
+  return !conformance.forEachMissingConformance(
+      [](BuiltinProtocolConformance *missing) {
+        return missing->getProtocol()->isSpecificProtocol(
+            KnownProtocolKind::Sendable);
+      });
 }
 
 bool TypeBase::isDistributedActor() {

lib/IDE/CompletionLookup.cpp

@@ -800,21 +800,20 @@ void CompletionLookup::analyzeActorIsolation(
   // If the reference is 'async', all types must be 'Sendable'.
   if (Ctx.LangOpts.StrictConcurrencyLevel >= StrictConcurrency::Complete &&
       implicitlyAsync && T) {
-    auto *M = CurrDeclContext->getParentModule();
     if (isa<VarDecl>(VD)) {
-      if (!isSendableType(M, T)) {
+      if (!T->isSendableType()) {
         NotRecommended = ContextualNotRecommendedReason::CrossActorReference;
       }
     } else {
       assert(isa<FuncDecl>(VD) || isa<SubscriptDecl>(VD));
       // Check if the result and the param types are all 'Sendable'.
       auto *AFT = T->castTo<AnyFunctionType>();
-      if (!isSendableType(M, AFT->getResult())) {
+      if (!AFT->getResult()->isSendableType()) {
         NotRecommended = ContextualNotRecommendedReason::CrossActorReference;
       } else {
         for (auto &param : AFT->getParams()) {
           Type paramType = param.getPlainType();
-          if (!isSendableType(M, paramType)) {
+          if (!paramType->isSendableType()) {
             NotRecommended =
                 ContextualNotRecommendedReason::CrossActorReference;
             break;

lib/IDE/IDETypeChecking.cpp

@@ -52,7 +52,9 @@ swift::getTopLevelDeclsForDisplay(ModuleDecl *M,
           !accessScope.isPublic() && !accessScope.isPackage())
         continue;
 
-      (void)swift::isSendableType(M, NTD->getDeclaredInterfaceType());
+      auto proto = M->getASTContext().getProtocol(KnownProtocolKind::Sendable);
+      if (proto)
+        (void) M->lookupConformance(NTD->getDeclaredInterfaceType(), proto);
     }
   }
 

lib/SIL/IR/SILType.cpp

@@ -1250,11 +1250,6 @@ SILType SILType::removingMoveOnlyWrapperToBoxedType(const SILFunction *fn) {
   return SILType::getPrimitiveObjectType(newBoxType);
 }
 
-ProtocolConformanceRef
-SILType::conformsToProtocol(SILFunction *fn, ProtocolDecl *protocol) const {
-  return fn->getParentModule()->checkConformance(getASTType(), protocol);
-}
-
 bool SILType::isSendable(SILFunction *fn) const {
-  return getASTType()->isSendableType(fn->getParentModule());
+  return getASTType()->isSendableType();
 }

lib/SILOptimizer/Mandatory/FlowIsolation.cpp

@@ -499,7 +499,7 @@ static bool accessIsConcurrencySafe(ModuleDecl *module,
 
   // must be accessible from nonisolated and Sendable
   return isLetAccessibleAnywhere(module, var)
-      && isSendableType(module, var->getTypeInContext());
+      && var->getTypeInContext()->isSendableType();
 }
 
 /// \returns true iff the ref_element_addr instruction is only used
@@ -517,11 +517,10 @@ static bool onlyDeinitAccess(RefElementAddrInst *inst) {
 /// diagnostic if it is not Sendable. The diagnostic assumes that the access
 /// is happening in a deinit that uses flow-isolation.
 /// \returns true iff a diagnostic was emitted for this reference.
-static bool diagnoseNonSendableFromDeinit(ModuleDecl *module,
-                                          RefElementAddrInst *inst) {
+static bool diagnoseNonSendableFromDeinit(RefElementAddrInst *inst) {
   VarDecl *var = inst->getField();
   Type ty = var->getTypeInContext();
-  DeclContext* dc = inst->getFunction()->getDeclContext();
+  DeclContext *dc = inst->getFunction()->getDeclContext();
 
 // FIXME: we should emit diagnostics in other modes using:
 //
@@ -534,7 +533,7 @@ static bool diagnoseNonSendableFromDeinit(ModuleDecl *module,
       != StrictConcurrency::Complete)
       return false;
 
-  if (isSendableType(module, ty))
+  if (ty->isSendableType())
     return false;
 
   auto &diag = var->getASTContext().Diags;
@@ -657,7 +656,7 @@ void AnalysisInfo::analyze(const SILArgument *selfParam) {
           continue;
 
         // emit a diagnostic and skip if it's non-sendable in a deinit
-        if (forDeinit && diagnoseNonSendableFromDeinit(module, refInst))
+        if (forDeinit && diagnoseNonSendableFromDeinit(refInst))
           continue;
 
         markPropertyUse(user);

lib/Sema/CodeSynthesis.cpp

@@ -361,7 +361,7 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
       auto type = var->getTypeInContext();
       auto isolation = getActorIsolation(var);
       if (isolation.isGlobalActor()) {
-        if (!isSendableType(decl->getModuleContext(), type) ||
+        if (!type->isSendableType() ||
             var->getInitializerIsolation().isGlobalActor()) {
           // If different isolated stored properties require different
           // global actors, it is impossible to initialize this type.

lib/Sema/ConstraintSystem.cpp

@@ -2806,8 +2806,7 @@ ConstraintSystem::getTypeOfMemberReference(
     FunctionType::ExtInfo info;
 
     if (Context.LangOpts.hasFeature(Feature::InferSendableFromCaptures)) {
-      if (isPartialApplication(locator) &&
-          isSendableType(DC->getParentModule(), baseOpenedTy)) {
+      if (isPartialApplication(locator) && baseOpenedTy->isSendableType()) {
         // Add @Sendable to functions without conditional conformances
         functionType =
             functionType

lib/Sema/TypeCheckAttr.cpp

@@ -6825,9 +6825,6 @@ void AttributeChecker::visitKnownToBeLocalAttr(KnownToBeLocalAttr *attr) {
 }
 
 void AttributeChecker::visitSendableAttr(SendableAttr *attr) {
-
-  auto dc = D->getDeclContext();
-
   if ((isa<AbstractFunctionDecl>(D) || isa<AbstractStorageDecl>(D)) &&
       !isAsyncDecl(cast<ValueDecl>(D))) {
     auto value = cast<ValueDecl>(D);
@@ -6841,8 +6838,8 @@ void AttributeChecker::visitSendableAttr(SendableAttr *attr) {
   }
   // Prevent Sendable Attr from being added to methods of non-sendable types
   if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(D)) {
-    if (auto selfdecl = funcDecl->getImplicitSelfDecl()) {
-      if (!isSendableType(dc->getParentModule(), selfdecl->getTypeInContext())) {
+    if (auto selfDecl = funcDecl->getImplicitSelfDecl()) {
+      if (!selfDecl->getTypeInContext()->isSendableType()) {
         diagnose(attr->getLocation(), diag::nonsendable_instance_method)
         .warnUntilSwiftVersion(6);
       }

lib/Sema/TypeCheckConcurrency.cpp

@@ -683,31 +683,6 @@ static bool isSendableClosure(
   return false;
 }
 
-/// Determine whether the given type is suitable as a concurrent value type.
-bool swift::isSendableType(ModuleDecl *module, Type type) {
-  auto proto = module->getASTContext().getProtocol(KnownProtocolKind::Sendable);
-  if (!proto)
-    return true;
-
-  // First check if we have a function type. If we do, check if it is
-  // Sendable. We do this since functions cannot conform to protocols.
-  if (auto *fas = type->getAs<SILFunctionType>())
-    return fas->isSendable();
-  if (auto *fas = type->getAs<AnyFunctionType>())
-    return fas->isSendable();
-
-  auto conformance = module->checkConformance(type, proto);
-  if (conformance.isInvalid())
-    return false;
-
-  // Look for missing Sendable conformances.
-  return !conformance.forEachMissingConformance(
-      [](BuiltinProtocolConformance *missing) {
-        return missing->getProtocol()->isSpecificProtocol(
-            KnownProtocolKind::Sendable);
-      });
-}
-
 /// Add Fix-It text for the given nominal type to adopt Sendable.
 static void addSendableFixIt(
     const NominalTypeDecl *nominal, InFlightDiagnostic &diag, bool unchecked) {
@@ -4741,8 +4716,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
           diagVar = originalVar;
         }
         if (var->isLet()) {
-          if (!isSendableType(var->getModuleContext(),
-                              var->getInterfaceType())) {
+          if (!var->getInterfaceType()->isSendableType()) {
             diagVar->diagnose(diag::shared_immutable_state_decl, diagVar)
                 .warnUntilSwiftVersion(6);
           }
@@ -6356,7 +6330,7 @@ ActorReferenceResult ActorReferenceResult::forReference(
         (!actorInstance || actorInstance->isSelf())) {
       auto type =
           fromDC->mapTypeIntoContext(declRef.getDecl()->getInterfaceType());
-      if (!isSendableType(fromDC->getParentModule(), type)) {
+      if (!type->isSendableType()) {
         // Treat the decl isolation as 'preconcurrency' to downgrade violations
         // to warnings, because violating Sendable here is accepted by the
         // Swift 5.9 compiler.