[SE-0470] Teach @sendable inference on static methods about non-sendable metatypes

The code that determines whether a reference to a static method (that
is not a call) assumed that metatypes were always Sendable. This is no
longer the case, so update this code to go through the normal Sendable
checking on the metatype.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -1949,7 +1949,7 @@ namespace {
             solution.setExprTypes(base);
             auto capture = new (ctx) VarDecl(/*static*/ false,
                                              VarDecl::Introducer::Let,
-                                             SourceLoc(),
+                                             base->getEndLoc(),
                                              ctx.getIdentifier("$base$"),
                                              dc);
             capture->setImplicit();

lib/Sema/TypeOfReference.cpp

@@ -849,19 +849,27 @@ FunctionType *ConstraintSystem::adjustFunctionTypeForConcurrency(
       } 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;
+          Type capturedBaseType = baseType;
+
+          if (!decl->isInstanceMember()) {
+            // Static member types are Sendable when the metatype of their
+            // base type is Sendable, because they capture that metatype.
+            // For example, `(S.Type) -> () -> Void`.
+            if (!capturedBaseType)
+              capturedBaseType = decl->getDeclContext()->getSelfTypeInContext();
+
+            if (!capturedBaseType->is<AnyMetatypeType>())
+              capturedBaseType = MetatypeType::get(capturedBaseType);
+          } else if (capturedBaseType) {
+            // 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.
+            capturedBaseType = capturedBaseType->getMetatypeInstanceType();
+          }
 
-          // 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();
+          return capturedBaseType && capturedBaseType->isSendableType();
         };
 
         auto referenceTy = adjustedTy->getResult()->castTo<FunctionType>();

test/Concurrency/sendable_metatype_typecheck.swift

@@ -87,3 +87,15 @@ nonisolated func passMetaWithMetaSendableVal<T: SendableMetatype & Q>(_: T.Type)
     x.g() // okay, because T is Sendable implies T.Type: Sendable
   }
 }
+
+struct GenericThingy<Element> {
+  func searchMe(_: (Element, Element) -> Bool) { }
+
+  func test() where Element: Comparable {
+    // Ensure that this we infer a non-@Sendable function type for Comparable.<
+    searchMe(<)
+
+    let _: (Element, Element) -> Bool = (>)
+    let _: @Sendable (Element, Element) -> Bool = (>) // expected-error{{converting non-sendable function value to '@Sendable (Element, Element) -> Bool' may introduce data races}}
+  }
+}