Merge pull request #70109 from xedin/fixes-for-member-sendability-inference

[ConstraintSystem] A couple of fixes to Sendable inference on functions

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -9532,34 +9532,6 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
     }
   }
 
-  // Delay solving member constraint for unapplied methods
-  // where the base type has a conditional Sendable conformance
-  if (Context.LangOpts.hasFeature(Feature::InferSendableFromCaptures)) {
-    if (isPartialApplication(memberLocator)) {
-      auto sendableProtocol = Context.getProtocol(KnownProtocolKind::Sendable);
-      auto baseConformance = DC->getParentModule()->lookupConformance(
-          instanceTy, sendableProtocol);
-
-      if (llvm::any_of(
-              baseConformance.getConditionalRequirements(),
-              [&](const auto &req) {
-                if (req.getKind() != RequirementKind::Conformance)
-                  return false;
-
-                if (auto protocolTy =
-                        req.getSecondType()->template getAs<ProtocolType>()) {
-                  return req.getFirstType()->hasTypeVariable() &&
-                         protocolTy->getDecl()->isSpecificProtocol(
-                             KnownProtocolKind::Sendable);
-                }
-                return false;
-              })) {
-        result.OverallResult = MemberLookupResult::Unsolved;
-        return result;
-      }
-    }
-  }
-
   // Okay, start building up the result list.
   result.OverallResult = MemberLookupResult::HasResults;
 
@@ -10078,6 +10050,46 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
     return OverloadChoice(baseTy, cand, functionRefKind);
   };
 
+  // Delay solving member constraint for unapplied methods
+  // where the base type has a conditional Sendable conformance
+  if (Context.LangOpts.hasFeature(Feature::InferSendableFromCaptures)) {
+    auto shouldCheckSendabilityOfBase = [&]() {
+      // Static members are always sendable because they only capture
+      // metatypes which are Sendable.
+      if (baseObjTy->is<AnyMetatypeType>())
+        return false;
+
+      return isPartialApplication(memberLocator) &&
+             llvm::any_of(lookup, [&](const auto &result) {
+               return isa_and_nonnull<FuncDecl>(result.getValueDecl());
+             });
+    };
+
+    if (shouldCheckSendabilityOfBase()) {
+      auto sendableProtocol = Context.getProtocol(KnownProtocolKind::Sendable);
+      auto baseConformance = DC->getParentModule()->lookupConformance(
+          instanceTy, sendableProtocol);
+
+      if (llvm::any_of(
+              baseConformance.getConditionalRequirements(),
+              [&](const auto &req) {
+                if (req.getKind() != RequirementKind::Conformance)
+                  return false;
+
+                if (auto protocolTy =
+                        req.getSecondType()->template getAs<ProtocolType>()) {
+                  return req.getFirstType()->hasTypeVariable() &&
+                         protocolTy->getDecl()->isSpecificProtocol(
+                             KnownProtocolKind::Sendable);
+                }
+                return false;
+              })) {
+        result.OverallResult = MemberLookupResult::Unsolved;
+        return result;
+      }
+    }
+  }
+
   // Add all results from this lookup.
   for (auto result : lookup)
     addChoice(getOverloadChoice(result.getValueDecl(),

lib/Sema/ConstraintSystem.cpp

@@ -2470,7 +2470,10 @@ bool ConstraintSystem::isPartialApplication(ConstraintLocator *locator) {
 
   auto baseTy =
       simplifyType(getType(UDE->getBase()))->getWithoutSpecifierType();
-  return getApplicationLevel(*this, baseTy, UDE) < 2;
+  auto level = getApplicationLevel(*this, baseTy, UDE);
+  // Static members have base applied implicitly which means that their
+  // application level is lower.
+  return level < (baseTy->is<MetatypeType>() ? 1 : 2);
 }
 
 DeclReferenceType

test/Concurrency/sendable_methods.swift

@@ -206,3 +206,25 @@ func generic3<T>(_ x: T) async {
 
   await generic3(GenericS<NonSendable>.f)
 }
+
+// Make sure that static members are handled properly
+do {
+  struct X<T> {
+    init(_: T) {
+    }
+
+    static func test(_: T) {}
+  }
+
+  class Test<T> {
+    init(_: T) {
+      _ = X(self) // Ok
+      _ = X.init(self) // Ok
+      _ = Optional.some(self) // Ok
+
+      let _: @Sendable (Int) -> X<Int> = X.init // Ok
+      let _: @Sendable (Test<Int>) -> Void = X.test // Ok
+      let _ = X.test(self) // Ok
+    }
+  }
+}