[ConstraintSystem] InferSenableFromCaptures: Fix treatment of partially applied instance methods on non-Sendable base

In situations like:

```
class A {
  func test() {}
}
```

Fully uncurried function type should be @sendable but inner method
cannot be because it captures a non-Sendable type `A` when applied.

Author: xedin

lib/Sema/ConstraintSystem.cpp

@@ -1774,21 +1774,36 @@ FunctionType *ConstraintSystem::adjustFunctionTypeForConcurrency(
           adjustedTy =
               adjustedTy->withExtInfo(adjustedTy->getExtInfo().withSendable());
         }
-      } else if (numApplies < decl->getNumCurryLevels()) {
-        // Operators on protocols could be found via unqualified lookup and
-        // won't have a base type.
-        if (decl->isOperator() ||
-            (baseType &&
-             (baseType->is<AnyMetatypeType>() || baseType->isSendableType()))) {
-          auto referenceTy = adjustedTy->getResult()->castTo<FunctionType>();
+      } else if (numApplies < decl->getNumCurryLevels() &&
+                 decl->hasCurriedSelf() ) {
+        auto shouldMarkMemberTypeSendable = [&]() {
+          // Static member types are @Sendable on both levels because
+          // they only capture a metatype "base" that is always Sendable.
+          // For example, `(S.Type) -> () -> Void`.
+          if (!decl->isInstanceMember())
+            return true;
+
+          // For instance members we need to check whether instance type
+          // is Sendable because @Sendable function values cannot capture
+          // non-Sendable values (base instance type in this case).
+          // For example, `(C) -> () -> Void` where `C` should be Sendable
+          // for the inner function type to be Sendable as well.
+          return baseType &&
+                 baseType->getMetatypeInstanceType()->isSendableType();
+        };
+
+        auto referenceTy = adjustedTy->getResult()->castTo<FunctionType>();
+        if (shouldMarkMemberTypeSendable()) {
           referenceTy =
-              referenceTy->withExtInfo(referenceTy->getExtInfo().withSendable())
+              referenceTy
+                  ->withExtInfo(referenceTy->getExtInfo().withSendable())
                   ->getAs<FunctionType>();
-
-          adjustedTy =
-              FunctionType::get(adjustedTy->getParams(), referenceTy,
-                                adjustedTy->getExtInfo().withSendable());
         }
+
+        // @Sendable since fully uncurried type doesn't capture anything.
+        adjustedTy =
+            FunctionType::get(adjustedTy->getParams(), referenceTy,
+                              adjustedTy->getExtInfo().withSendable());
       }
     }
   }

test/Concurrency/sendable_methods.swift

@@ -305,4 +305,17 @@ do {
 
   let fn = S.foo(S())
   bar(fn) // Ok
+
+  let _: @Sendable (S) -> @Sendable () -> Void = S.foo // Ok
+
+  let classFn = NonSendable.f(NonSendable())
+  bar(classFn) // expected-warning {{converting non-sendable function value to '@Sendable () -> Void' may introduce data races}}
+
+  let _: @Sendable (NonSendable) -> () -> Void = NonSendable.f // Ok
+
+  class Test {
+    static func staticFn() {}
+  }
+
+  bar(Test.staticFn) // Ok
 }