Merge pull request #67498 from angela-laar/implicit-sendable-for-methods

[Sema] Implicitly add @sendable attribute to partial methods

Author: angela-laar

include/swift/Basic/Features.def

@@ -243,7 +243,6 @@ EXPERIMENTAL_FEATURE(RawLayout, true)
 /// Enables the "embedded" swift mode (no runtime).
 EXPERIMENTAL_FEATURE(Embedded, true)
 
-
 /// Enables noncopyable generics
 EXPERIMENTAL_FEATURE(NoncopyableGenerics, false)
 
@@ -260,6 +259,10 @@ EXPERIMENTAL_FEATURE(NonEscapableTypes, false)
 /// Enable the `@_extern` attribute.
 EXPERIMENTAL_FEATURE(Extern, true)
 
+// 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
 #undef UPCOMING_FEATURE

include/swift/Sema/ConstraintSystem.h

@@ -5433,6 +5433,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

@@ -3559,12 +3559,18 @@ static bool usesFeatureParameterPacks(Decl *decl) {
 
 static bool usesFeatureRegionBasedIsolation(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 usesFeatureInferSendableFromCaptures(Decl *decl) {
+  return false;
+}
+
 static bool usesFeaturePlaygroundExtendedCallbacks(Decl *decl) {
   return false;
 }

lib/Sema/CSSimplify.cpp

@@ -29,7 +29,9 @@
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/PropertyWrappers.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/Requirement.h"
 #include "swift/AST/SourceFile.h"
+#include "swift/AST/Types.h"
 #include "swift/Basic/StringExtras.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Sema/CSFix.h"
@@ -9511,16 +9513,18 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
   Type baseObjTy = baseTy->getRValueType();
   Type instanceTy = baseObjTy;
 
+  auto &ctx = getASTContext();
   auto memberNode = simplifyLocatorToAnchor(memberLocator);
   auto memberLoc = memberNode ? memberNode.getStartLoc() : SourceLoc();
 
   if (auto baseObjMeta = baseObjTy->getAs<AnyMetatypeType>()) {
     instanceTy = baseObjMeta->getInstanceType();
   }
 
+  MemberLookupResult result;
+
   if (instanceTy->isTypeVariableOrMember() ||
       instanceTy->is<UnresolvedType>()) {
-    MemberLookupResult result;
     result.OverallResult = MemberLookupResult::Unsolved;
     return result;
   }
@@ -9530,14 +9534,40 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
   if (isSingleUnlabeledPackExpansionTuple(instanceTy)) {
     auto elementTy = instanceTy->castTo<TupleType>()->getElementType(0);
     if (elementTy->is<TypeVariableType>()) {
-      MemberLookupResult result;
       result.OverallResult = MemberLookupResult::Unsolved;
       return result;
     }
   }
 
+  // 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.
-  MemberLookupResult result;
   result.OverallResult = MemberLookupResult::HasResults;
 
   // Add key path result.
@@ -9559,7 +9589,6 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
 
   // If the base type is a tuple type, look for the named or indexed member
   // of the tuple.
-  auto &ctx = getASTContext();
   if (auto baseTuple = baseObjTy->getAs<TupleType>()) {
     if (!memberName.isSpecial()) {
       StringRef nameStr = memberName.getBaseIdentifier().str();

lib/Sema/ConstraintSystem.cpp

@@ -1160,7 +1160,6 @@ FunctionType *ConstraintSystem::openFunctionType(
        DeclContext *outerDC) {
   if (auto *genericFn = funcType->getAs<GenericFunctionType>()) {
     auto signature = genericFn->getGenericSignature();
-
     openGenericParameters(outerDC, signature, replacements, locator);
 
     openGenericRequirements(outerDC, signature,
@@ -1612,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},
@@ -1665,6 +1665,8 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
                                      FunctionRefKind functionRefKind,
                                      ConstraintLocatorBuilder locator,
                                      DeclContext *useDC) {
+  auto &ctx = getASTContext();
+
   if (value->getDeclContext()->isTypeContext() && isa<FuncDecl>(value)) {
     // Unqualified lookup can find operator names within nominal types.
     auto func = cast<FuncDecl>(value);
@@ -1711,6 +1713,14 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     auto numLabelsToRemove = getNumRemovedArgumentLabels(
         funcDecl, /*isCurriedInstanceReference=*/false, functionRefKind);
 
+    if (Context.LangOpts.hasFeature(Feature::InferSendableFromCaptures)) {
+      // All global functions should be @Sendable
+      if (!funcDecl->getDeclContext()->isTypeContext() && !funcDecl->getDeclContext()->isLocalContext() ) {
+        funcType =
+            funcType->withExtInfo(funcType->getExtInfo().withConcurrent());
+      }
+    }
+
     auto openedType = openFunctionType(funcType, locator, replacements,
                                        funcDecl->getDeclContext())
                           ->removeArgumentLabels(numLabelsToRemove);
@@ -2416,6 +2426,36 @@ Type ConstraintSystem::getMemberReferenceTypeFromOpenedType(
   return type;
 }
 
+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.
+  if (locator->isLastElement<LocatorPathElt::ConstructorMember>() &&
+      locator->findFirst<LocatorPathElt::ImplicitConversion>())
+    return false;
+
+  auto *UDE = getAsExpr<UnresolvedDotExpr>(locator->getAnchor());
+  if (UDE == nullptr)
+    return false;
+
+  auto baseTy =
+      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
+  // application level already.
+  unsigned level = 0;
+  if (!baseTy->is<MetatypeType>())
+    ++level;
+
+  if (auto *call = dyn_cast_or_null<CallExpr>(getParentExpr(UDE))) {
+    if (UDE == call->getFn()->getSemanticsProvidingExpr())
+      level += 1;
+  }
+
+  return level < 2;
+}
+
 DeclReferenceType
 ConstraintSystem::getTypeOfMemberReference(
     Type baseTy, ValueDecl *value, DeclContext *useDC,
@@ -2626,6 +2666,17 @@ ConstraintSystem::getTypeOfMemberReference(
                                                        functionType, locator);
     // 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();
+    }
+
     openedType =
         FunctionType::get(fullFunctionType->getParams(), functionType, info);
   }

lib/Sema/TypeCheckConcurrency.cpp

@@ -1952,7 +1952,6 @@ bool swift::diagnoseApplyArgSendability(ApplyExpr *apply, const DeclContext *dec
             isolationCrossing.value().getDiagnoseIsolation()))
       return true;
   }
-
   auto fnType = fnExprType->getAs<FunctionType>();
   if (!fnType)
     return false;
@@ -5527,6 +5526,7 @@ AnyFunctionType *swift::adjustFunctionTypeForConcurrency(
   // Apply unsafe concurrency features to the given function type.
   bool strictChecking = contextRequiresStrictConcurrencyChecking(
       dc, getType, isolatedByPreconcurrency);
+
   fnType = applyUnsafeConcurrencyToFunctionType(
       fnType, decl, strictChecking, numApplies, isMainDispatchQueue);