[Frontend] Feature flag for InferredSendableMethods

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)
 
@@ -253,12 +252,18 @@ EXPERIMENTAL_FEATURE(TypedThrows, true)
 /// Allow destructuring stored `let` bindings in structs.
 EXPERIMENTAL_FEATURE(StructLetDestructuring, true)
 
+<<<<<<< HEAD
 /// Enable non-escapable type attributes and function attributes that support
 /// lifetime-dependent results.
 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)
+>>>>>>> 175f54caad6 ([Frontend] Feature flag for InferredSendableMethods)
 
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3579,6 +3579,8 @@ static bool usesFeatureIsolatedDefaultValues(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureInferSendableMethods(Decl *decl) { return false; }
+
 static bool usesFeaturePlaygroundExtendedCallbacks(Decl *decl) {
   return false;
 }

lib/Sema/CSSimplify.cpp

@@ -9494,6 +9494,7 @@ 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();
 
@@ -9521,13 +9522,20 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
 
   // Delay solving member constraint for unapplied methods
   // where the base type has a conditional Sendable conformance
-  if (functionRefKind == FunctionRefKind::Unapplied) {
-    auto sendableProtocol = DC->getParentModule()->getASTContext().getProtocol(KnownProtocolKind::Sendable);
-    auto baseSendable = swift::TypeChecker::conformsToProtocol(instanceTy, sendableProtocol, DC->getParentModule());
-
-    if (!baseSendable.isInvalid() && !baseSendable.getConditionalRequirements().empty() && instanceTy->hasTypeVariable()) {
-      result.OverallResult = MemberLookupResult::Unsolved;
-      return result;
+  if (ctx.LangOpts.hasFeature(Feature::InferSendableMethods)) {
+    if (functionRefKind == FunctionRefKind::Unapplied) {
+      auto sendableProtocol =
+          DC->getParentModule()->getASTContext().getProtocol(
+              KnownProtocolKind::Sendable);
+      auto baseSendable = swift::TypeChecker::conformsToProtocol(
+          instanceTy, sendableProtocol, DC->getParentModule());
+
+      if (!baseSendable.isInvalid() &&
+          !baseSendable.getConditionalRequirements().empty() &&
+          instanceTy->hasTypeVariable()) {
+        result.OverallResult = MemberLookupResult::Unsolved;
+        return result;
+      }
     }
   }
 
@@ -9553,7 +9561,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();
@@ -10531,8 +10538,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
     // If requested, generate a constraint.
     if (flags.contains(TMF_GenerateConstraints)) {
       auto *memberRef = Constraint::createMemberOrOuterDisjunction(
-      *this, kind, baseTy, memberTy, member, useDC, functionRefKind,
-       outerAlternatives, locator);
+          *this, kind, baseTy, memberTy, member, useDC, functionRefKind,
+          outerAlternatives, locator);
 
       addUnsolvedConstraint(memberRef);
 
@@ -10587,7 +10594,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
         // It could either be a hole associated directly with the base
         // or a hole which came from result type of the chain.
         if (originatorLoc->isLastElement<
-            LocatorPathElt::UnresolvedMemberChainResult>()) {
+                LocatorPathElt::UnresolvedMemberChainResult>()) {
           auto *UMCR = castToExpr<UnresolvedMemberChainResultExpr>(
               originatorLoc->getAnchor());
           return UMCR->getChainBase() == getAsExpr(locator->getAnchor());

lib/Sema/ConstraintSystem.cpp

@@ -2623,31 +2623,46 @@ ConstraintSystem::getTypeOfMemberReference(
     auto *functionType = fullFunctionType->getResult()->getAs<FunctionType>();
     functionType = unwrapPropertyWrapperParameterTypes(*this, funcDecl, functionRefKind,
                                                        functionType, locator);
-    auto sendableProtocol = useDC->getParentModule()->getASTContext().getProtocol(KnownProtocolKind::Sendable);
-    auto baseSendable = TypeChecker::conformsToProtocol( baseOpenedTy, sendableProtocol, useDC->getParentModule());
-
-    if (isSendableType(useDC->getParentModule(), baseOpenedTy)) {
-      if (baseSendable.getConditionalRequirements().empty())
-        //Functions w/o conditional conformances should be marked @Sendable
-        functionType = functionType->withExtInfo(functionType->getExtInfo().withConcurrent())->getAs<FunctionType>();
-
-      // Handle Conditional Conformances
-      for (auto req : baseSendable.getConditionalRequirements()){
-        if(!TypeChecker::conformsToProtocol( req.getFirstType(), sendableProtocol, useDC->getParentModule()).isInvalid()){
+    auto &ctx = DC->getASTContext();
+    auto *parentModule = useDC->getParentModule();
+    bool baseSendable = isSendableType(parentModule, baseOpenedTy);
+    bool inferredSendable =
+        ctx.LangOpts.hasFeature(Feature::InferSendableMethods);
+
+    if (inferredSendable) {
+      auto sendableProtocol = parentModule->getASTContext().getProtocol(
+          KnownProtocolKind::Sendable);
+      auto baseConformance = TypeChecker::conformsToProtocol(
+          baseOpenedTy, sendableProtocol, parentModule);
+
+      if (baseSendable) {
+        // Add @Sendable to functions without conditional conformances
+        if (baseConformance.getConditionalRequirements().empty())
           functionType = functionType->withExtInfo(functionType->getExtInfo().withConcurrent())->getAs<FunctionType>();
+
+        // Handle Conditional Conformances
+        for (auto req : baseConformance.getConditionalRequirements()) {
+          if (!TypeChecker::conformsToProtocol(req.getFirstType(),
+                                               sendableProtocol, parentModule)
+                   .isInvalid())
+            functionType =
+                functionType
+                    ->withExtInfo(functionType->getExtInfo().withConcurrent())
+                    ->getAs<FunctionType>();
         }
       }
     }
-    
+
     // FIXME: Verify ExtInfo state is correct, not working by accident.
     FunctionType::ExtInfo info;
     openedType =
         FunctionType::get(fullFunctionType->getParams(), functionType, info);
 
-    if (isSendableType(useDC->getParentModule(), baseOpenedTy)) {
-      // If this is actually a Sendable type, implicitly mark @Sendable
+    // Add @Sendable to openedType if possible
+    if (inferredSendable && baseSendable) {
       auto origFnType = openedType->castTo<FunctionType>();
-      openedType = origFnType->withExtInfo(origFnType->getExtInfo().withConcurrent());
+      openedType =
+          origFnType->withExtInfo(origFnType->getExtInfo().withConcurrent());
     }
   }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -5481,12 +5481,19 @@ AnyFunctionType *swift::adjustFunctionTypeForConcurrency(
   bool strictChecking = contextRequiresStrictConcurrencyChecking(
       dc, getType, isolatedByPreconcurrency);
 
-  auto func = dyn_cast_or_null<AbstractFunctionDecl>(decl);
-  auto doesNotCapture = func->getCaptureInfo().getCaptures().empty();
+  auto &ctx = dc->getASTContext();
+  bool inferredSendable =
+      ctx.LangOpts.hasFeature(Feature::InferSendableMethods);
 
-  if (doesNotCapture) {
-    fnType = fnType->withExtInfo(fnType->getExtInfo().withConcurrent());
-    return fnType;
+  if (inferredSendable) {
+    if (auto func = dyn_cast_or_null<AbstractFunctionDecl>(decl)) {
+      auto doesNotCapture = func->getCaptureInfo().getCaptures().empty();
+
+      if (doesNotCapture) {
+        fnType = fnType->withExtInfo(fnType->getExtInfo().withConcurrent());
+        return fnType;
+      }
+    }
   }
 
   fnType = applyUnsafeConcurrencyToFunctionType(

test/Concurrency/sendable_methods.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift-enable -experimental-feature InferSendableMethods
 // REQUIRES: concurrency
 
 final class C : Sendable {
@@ -77,10 +77,8 @@ g(InferredSendableE.f)
 g(GenericS<Int>.f)
 g(GenericC<Int>.f)
 
-g(GenericS<NonSendable>.f) // expected-warning{{converting non-sendable function value to '@Sendable (GenericS<NonSendable>) -> (@Sendable () -> Void)' may introduce data races
-// expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races
-g(GenericC<NonSendable>.f) // expected-warning{{converting non-sendable function value to '@Sendable (GenericS<NonSendable>) -> (@Sendable () -> Void)' may introduce data races
-// expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races
+g(GenericS<NonSendable>.f) // expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races
+g(GenericC<NonSendable>.f) // expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races
 
 func executeAsTask (_ f: @escaping  @Sendable () -> Void) {
   Task {