[Constraint System] Always add Sendable to unapplied function applications

Author: angela-laar

include/swift/Basic/Features.def

@@ -259,9 +259,9 @@ EXPERIMENTAL_FEATURE(NonEscapableTypes, false)
 /// Enable the `@extern` attribute.
 EXPERIMENTAL_FEATURE(Extern, true)
 
-// Infer Sendability of unapplied and partial applied methods
-// based on type. Global functions are always implicitly Sendable
-EXPERIMENTAL_FEATURE(InferSendableMethods, false)
+// Infer Sendability of unapplied and partial applied methods,
+// global functions and key paths.
+EXPERIMENTAL_FEATURE(InferSendableFromCaptures, false)
 
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE

include/swift/Sema/ConstraintSystem.h

@@ -5420,6 +5420,8 @@ class ConstraintSystem {
     return range.isValid() ? range : llvm::Optional<SourceRange>();
   }
 
+  bool isPartialApplication(ConstraintLocator *locator);
+
   bool isTooComplex(size_t solutionMemory) {
     if (isAlreadyTooComplex.first)
       return true;

lib/AST/ASTPrinter.cpp

@@ -3573,13 +3573,17 @@ static bool usesFeatureSendNonSendable(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureGlobalConcurrency(Decl *decl) { return false; }
+static bool usesFeatureGlobalConcurrency(Decl *decl) {
+  return false;
+}
 
 static bool usesFeatureIsolatedDefaultValues(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureInferSendableMethods(Decl *decl) { return false; }
+static bool usesFeatureInferSendableFromCaptures(Decl *decl) {
+  return false;
+}
 
 static bool usesFeaturePlaygroundExtendedCallbacks(Decl *decl) {
   return false;

lib/Sema/CSSimplify.cpp

@@ -9524,32 +9524,25 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
 
   // Delay solving member constraint for unapplied methods
   // where the base type has a conditional Sendable conformance
-  if (ctx.LangOpts.hasFeature(Feature::InferSendableMethods)) {
-    if (functionRefKind == FunctionRefKind::Unapplied) {
+  if (Context.LangOpts.hasFeature(Feature::InferSendableFromCaptures)) {
+    if (isPartialApplication(memberLocator)) {
       auto sendableProtocol =
-          DC->getParentModule()->getASTContext().getProtocol(
+          Context.getProtocol(
               KnownProtocolKind::Sendable);
       auto baseConformance = DC->getParentModule()->lookupConformance(
           instanceTy, sendableProtocol);
 
       if (llvm::any_of(
               baseConformance.getConditionalRequirements(),
               [&](const auto &req) {
-                switch (req.getKind()) {
-                case RequirementKind::Conformance: {
-                  if (auto secondType =
-                          req.getSecondType()->template getAs<ProtocolType>()) {
-                    return req.getFirstType()->hasTypeVariable() &&
-                           secondType->getDecl()->isSpecificProtocol(
-                               KnownProtocolKind::Sendable);
-                  }
-                }
-                case RequirementKind::Superclass:
-                case RequirementKind::SameType:
-                case RequirementKind::SameShape:
-                case RequirementKind::Layout:
+                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;

lib/Sema/ConstraintSystem.cpp

@@ -1611,6 +1611,7 @@ AnyFunctionType *ConstraintSystem::adjustFunctionTypeForConcurrency(
     AnyFunctionType *fnType, ValueDecl *decl, DeclContext *dc,
     unsigned numApplies, bool isMainDispatchQueue, OpenedTypeMap &replacements,
     ConstraintLocatorBuilder locator) {
+
   return swift::adjustFunctionTypeForConcurrency(
       fnType, decl, dc, numApplies, isMainDispatchQueue,
       GetClosureType{*this}, ClosureIsolatedByPreconcurrency{*this},
@@ -1712,12 +1713,11 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     auto numLabelsToRemove = getNumRemovedArgumentLabels(
         funcDecl, /*isCurriedInstanceReference=*/false, functionRefKind);
 
-    if (ctx.LangOpts.hasFeature(Feature::InferSendableMethods)) {
+    if (Context.LangOpts.hasFeature(Feature::InferSendableFromCaptures)) {
       // All global functions should be @Sendable
-      if (funcDecl->getDeclContext()->isLocalContext()) {
+      if (!funcDecl->getDeclContext()->isTypeContext() && !funcDecl->getDeclContext()->isLocalContext() ) {
         funcType =
-            funcType->withExtInfo(funcType->getExtInfo().withConcurrent())
-                ->getAs<AnyFunctionType>();
+            funcType->withExtInfo(funcType->getExtInfo().withConcurrent());
       }
     }
 
@@ -2426,10 +2426,7 @@ Type ConstraintSystem::getMemberReferenceTypeFromOpenedType(
   return type;
 }
 
-
-bool isPartialApplication(ConstraintSystem &cs,
-                            const AbstractFunctionDecl *member,
-                            ConstraintLocator *locator) {
+bool ConstraintSystem::isPartialApplication(ConstraintLocator *locator) {
   // If this is a compiler synthesized implicit conversion, let's skip
   // the check because the base of `UDE` is not the base of the injected
   // initializer.
@@ -2442,7 +2439,7 @@ bool isPartialApplication(ConstraintSystem &cs,
     return false;
 
   auto baseTy =
-      cs.simplifyType(cs.getType(UDE->getBase()))->getWithoutSpecifierType();
+      simplifyType(getType(UDE->getBase()))->getWithoutSpecifierType();
 
   // If base is a metatype it would be ignored (unless this is an initializer
   // call), but if it is some other type it means that we have a single
@@ -2451,14 +2448,12 @@ bool isPartialApplication(ConstraintSystem &cs,
   if (!baseTy->is<MetatypeType>())
     ++level;
 
-  if (auto *call = dyn_cast_or_null<CallExpr>(cs.getParentExpr(UDE))) {
-    level += 1;
+  if (auto *call = dyn_cast_or_null<CallExpr>(getParentExpr(UDE))) {
+    if (UDE == call->getFn()->getSemanticsProvidingExpr())
+      level += 1;
   }
 
-  if (level == 2)
-    return false;
-
-  return true;
+  return level < 2;
 }
 
 DeclReferenceType
@@ -2669,37 +2664,21 @@ ConstraintSystem::getTypeOfMemberReference(
     auto *functionType = fullFunctionType->getResult()->getAs<FunctionType>();
     functionType = unwrapPropertyWrapperParameterTypes(*this, funcDecl, functionRefKind,
                                                        functionType, locator);
-    auto &ctx = DC->getASTContext();
-    auto *parentModule = useDC->getParentModule();
-    bool inferredSendable =
-        ctx.LangOpts.hasFeature(Feature::InferSendableMethods);
-
-    bool isPartialApply;
-    isPartialApply = isPartialApplication(*this, funcDecl, locator);
-   
-    if (inferredSendable && isPartialApply) {
-//      auto sendableProtocol = parentModule->getASTContext().getProtocol(
-//          KnownProtocolKind::Sendable);
-//      auto baseConformance =
-//          parentModule->lookupConformance(baseOpenedTy, sendableProtocol);
-      
-      if (isSendableType(parentModule, baseOpenedTy)) {
+    // FIXME: Verify ExtInfo state is correct, not working by accident.
+    FunctionType::ExtInfo info;
+
+    if (Context.LangOpts.hasFeature(Feature::InferSendableFromCaptures)) {
+      if (isPartialApplication(locator) &&
+          isSendableType(DC->getParentModule(), baseOpenedTy)) {
         // Add @Sendable to functions without conditional conformances
         functionType = functionType->withExtInfo(functionType->getExtInfo().withConcurrent())->getAs<FunctionType>();
       }
+      // Unapplied values should always be Sendable
+      info = info.withConcurrent();
     }
 
-    // FIXME: Verify ExtInfo state is correct, not working by accident.
-    FunctionType::ExtInfo info;
     openedType =
         FunctionType::get(fullFunctionType->getParams(), functionType, info);
-
-    // Add @Sendable to openedType if possible
-    if (inferredSendable) {
-      auto origFnType = openedType->castTo<FunctionType>();
-      openedType =
-          origFnType->withExtInfo(origFnType->getExtInfo().withConcurrent());
-    }
   }
 
   // Adjust the opened type for concurrency.

lib/Sema/TypeCheckConcurrency.cpp

@@ -5481,8 +5481,6 @@ AnyFunctionType *swift::adjustFunctionTypeForConcurrency(
   bool strictChecking = contextRequiresStrictConcurrencyChecking(
       dc, getType, isolatedByPreconcurrency);
 
-  auto &ctx = dc->getASTContext();
-
   fnType = applyUnsafeConcurrencyToFunctionType(
       fnType, decl, strictChecking, numApplies, isMainDispatchQueue);