NCGenerics: handle legacy definition of Sendable

This should be a temporary measure while bootstrapping the feature.

Author: kavon

lib/AST/ASTPrinter.cpp

@@ -1586,7 +1586,9 @@ void PrintAST::printInheritedFromRequirementSignature(ProtocolDecl *proto,
 
   // The invertible protocols themselves do not need to state inverses in their
   // inheritance clause, because they do not gain any default requirements.
-  if (!proto->getInvertibleProtocolKind())
+  // HACK: also exclude Sendable from getting inverses printed.
+  if (!proto->getInvertibleProtocolKind()
+      && !proto->isSpecificProtocol(KnownProtocolKind::Sendable))
     flags |= PrintInverseRequirements;
 
   printRequirementSignature(

lib/AST/Decl.cpp

@@ -6634,6 +6634,11 @@ bool ProtocolDecl::requiresInvertible(InvertibleProtocolKind ip) const {
     if (proto->getInvertibleProtocolKind())
       return TypeWalker::Action::Continue;
 
+    // HACK: claim that Sendable also doesn't implicitly inherit Copyable, etc.
+    // This shouldn't be needed after Swift 6.0
+    if (proto->isSpecificProtocol(KnownProtocolKind::Sendable))
+      return TypeWalker::Action::Continue;
+
     // Otherwise, check to see if there's an inverse on this protocol.
     switch (proto->getMarking(ip).getInverse().getKind()) {
     case InverseMarking::Kind::None:

lib/AST/NameLookup.cpp

@@ -3081,6 +3081,16 @@ DirectlyReferencedTypeDecls InheritedDeclsReferencedRequest::evaluate(
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
     unsigned index) const {
 
+  // FIXME: this is an awful hack for NoncopyableGenerics.
+  // The correct fix here is to integrate the guts of
+  // `ProtocolDecl::requiresInvertible` into this request, so that it works
+  // automatically, not only for `ProtocolDecl::inheritsFrom` but for other
+  // nominal types too.
+  if (auto typeDecl = decl.dyn_cast<const TypeDecl *>())
+    if (auto protoDecl = dyn_cast<ProtocolDecl>(typeDecl))
+      if (protoDecl->isSpecificProtocol(KnownProtocolKind::Sendable))
+        return {};
+
   // Prefer syntactic information when we have it.
   const TypeLoc &typeLoc = InheritedTypes(decl).getEntry(index);
   if (auto typeRepr = typeLoc.getTypeRepr()) {

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -987,7 +987,10 @@ StructuralRequirementsRequest::evaluate(Evaluator &evaluator,
 
   SmallVector<StructuralRequirement, 2> defaults;
   // We do not expand defaults for invertible protocols themselves.
-  if (!proto->getInvertibleProtocolKind())
+  // HACK: We don't expand for Sendable either. This shouldn't be needed after
+  // Swift 6.0
+  if (!proto->getInvertibleProtocolKind()
+      && !proto->isSpecificProtocol(KnownProtocolKind::Sendable))
     InverseRequirement::expandDefaults(ctx, needsDefaultRequirements, defaults);
 
   applyInverses(ctx, needsDefaultRequirements, inverses, defaults, errors);

test/Sema/moveonly_sendable_legacy.swift

@@ -0,0 +1,21 @@
+// RUN: %target-typecheck-verify-swift \
+// RUN:   -parse-stdlib -module-name Swift \
+// RUN:   -enable-experimental-feature NoncopyableGenerics
+
+@_marker protocol Copyable {}
+
+// This is how Sendable was defined prior to NoncopyableGenerics.
+// Notice that there is no ~Copyable or ~Escapable on it. That would normally
+// imply that it requires Copyable & Escapable. We don't want that.
+//
+// In order to allow bootstrapping with hostlibs and various mix-and-matched
+// compilers and stdlibs this test ensures that we still treat this legacy
+// definition of Sendable as if it does _not_ require Copyable and Escapable.
+@_marker protocol Sendable {}
+
+enum E: ~Copyable, Sendable {}
+@_moveOnly struct S: Sendable {}
+
+// expected-note@+2 3{{add}}
+// expected-error@+1 {{parameter of noncopyable type 'T' must specify ownership}}
+func checkGeneric<T>(_ t: T) where T: ~Copyable, T: Sendable {}