[CSSimplify] Check all conditional requirements for a type variable

Author: angela-laar

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"
@@ -9527,12 +9529,28 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
       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()) {
+      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:
+                  return false;
+                }
+              })) {
         result.OverallResult = MemberLookupResult::Unsolved;
         return result;
       }

lib/Sema/ConstraintSystem.cpp

@@ -1665,7 +1665,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
                                      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,14 +1711,16 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     auto funcType = funcDecl->getInterfaceType()->castTo<AnyFunctionType>();
     auto numLabelsToRemove = getNumRemovedArgumentLabels(
         funcDecl, /*isCurriedInstanceReference=*/false, functionRefKind);
-    
+
     if (ctx.LangOpts.hasFeature(Feature::InferSendableMethods)) {
       // All global functions should be @Sendable
-      if(funcDecl->getDeclContext()->isLocalContext()) {
-        funcType = funcType->withExtInfo(funcType->getExtInfo().withConcurrent())->getAs<AnyFunctionType>();
+      if (funcDecl->getDeclContext()->isLocalContext()) {
+        funcType =
+            funcType->withExtInfo(funcType->getExtInfo().withConcurrent())
+                ->getAs<AnyFunctionType>();
       }
     }
-    
+
     auto openedType = openFunctionType(funcType, locator, replacements,
                                        funcDecl->getDeclContext())
                           ->removeArgumentLabels(numLabelsToRemove);
@@ -2641,26 +2643,27 @@ ConstraintSystem::getTypeOfMemberReference(
     if (inferredSendable) {
       auto sendableProtocol = parentModule->getASTContext().getProtocol(
           KnownProtocolKind::Sendable);
-      auto baseConformance = TypeChecker::conformsToProtocol(
-          baseOpenedTy, sendableProtocol, parentModule);
+      auto baseConformance =
+          parentModule->lookupConformance(baseOpenedTy, sendableProtocol);
 
       if (baseTypeSendable) {
         // Add @Sendable to functions without conditional conformances
-        if (baseConformance.getConditionalRequirements().empty()){
+        if (baseConformance.getConditionalRequirements().empty()) {
           functionType = functionType->withExtInfo(functionType->getExtInfo().withConcurrent())->getAs<FunctionType>();
         } else {
           // Handle Conditional Conformances
           auto substitutionMap = SubstitutionMap::getProtocolSubstitutions(
-                                                                           sendableProtocol, baseOpenedTy,
-                                                                           baseConformance);
-          
-          auto result = TypeChecker::checkGenericArguments(parentModule, baseConformance.getConditionalRequirements(), QuerySubstitutionMap{substitutionMap} );
-          
+              sendableProtocol, baseOpenedTy, baseConformance);
+
+          auto result = TypeChecker::checkGenericArguments(
+              parentModule, baseConformance.getConditionalRequirements(),
+              QuerySubstitutionMap{substitutionMap});
+
           if (result == CheckGenericArgumentsResult::Success) {
             functionType =
-            functionType
-            ->withExtInfo(functionType->getExtInfo().withConcurrent())
-            ->getAs<FunctionType>();
+                functionType
+                    ->withExtInfo(functionType->getExtInfo().withConcurrent())
+                    ->getAs<FunctionType>();
           }
         }
       }
@@ -2672,10 +2675,10 @@ ConstraintSystem::getTypeOfMemberReference(
         FunctionType::get(fullFunctionType->getParams(), functionType, info);
 
     // Add @Sendable to openedType if possible
-    if (inferredSendable){
+    if (inferredSendable) {
       auto origFnType = openedType->castTo<FunctionType>();
       openedType =
-      origFnType->withExtInfo(origFnType->getExtInfo().withConcurrent());
+          origFnType->withExtInfo(origFnType->getExtInfo().withConcurrent());
     }
   }
 

test/Concurrency/sendable_methods.swift

@@ -41,7 +41,9 @@ enum InferredSendableE: P {
 }
 
 struct GenericS<T>: P {
-  func f() { }
+    init(_: T) { }
+
+    func f() { }
 }
 
 final class GenericC<T>: P {
@@ -80,6 +82,9 @@ g(GenericC<Int>.f)
 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
 
+g(GenericS(NonSendable()).f) // expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races
+g(GenericS(1).f)
+
 func executeAsTask (_ f: @escaping  @Sendable () -> Void) {
   Task {
     f()
@@ -133,3 +138,8 @@ func doWork() -> Int {
 let work: @Sendable () -> Int = doWork
 Task<Int, Never>.detached(priority: nil, operation: doWork)
 Task<Int, Never>.detached(priority: nil, operation: work)
+
+func generic<T>(_: T) {
+    Task<Int, Never>.detached(priority: nil, operation: T)
+}
+generic(GenericS<Int>.f) // generic argument for `T` should be inferred as `@escaping @Sendable`