Merge pull request #71654 from kavon/ncgenerics-test-fixes-kavon-v14

kavon · web-flow · commit 4fb90d3e2c5f · 2024-02-15T14:04:50.000-08:00
Ncgenerics test fixes kavon v14
diff --git a/lib/AST/ASTPrinter.cpp b/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(
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -6636,6 +6636,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:
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
@@ -883,6 +883,11 @@ void GenericSignature::verify() const {
 }
 
 void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
+  auto dumpAndAbort = [&]() {
+    getPointer()->getRequirementMachine()->dump(llvm::errs());
+    abort();
+  };
+
   auto canSig = getCanonicalSignature();
 
   PrettyStackTraceGenericSignature debugStack("checking", canSig);
@@ -903,14 +908,14 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
         llvm::errs() << "Left-hand side must be a type parameter: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
 
       if (!canSig->isReducedType(reqt.getFirstType())) {
         llvm::errs() << "Left-hand side is not reduced: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
     }
 
@@ -921,28 +926,28 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
         llvm::errs() << "Left hand side is not a generic parameter: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
 
       if (!reqt.getFirstType()->isRootParameterPack()) {
         llvm::errs() << "Left hand side is not a parameter pack: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
 
       if (!reqt.getSecondType()->is<GenericTypeParamType>()) {
         llvm::errs() << "Right hand side is not a generic parameter: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
 
       if (!reqt.getSecondType()->isRootParameterPack()) {
         llvm::errs() << "Right hand side is not a parameter pack: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
 
       break;
@@ -951,7 +956,7 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
         llvm::errs() << "Right-hand side is not reduced: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
       break;
 
@@ -977,21 +982,21 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
         llvm::errs() << "Left hand side does not have a reduced parent: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
 
       if (reqt.getSecondType()->isTypeParameter()) {
         if (!hasReducedOrConcreteParent(secondType)) {
           llvm::errs() << "Right hand side does not have a reduced parent: ";
           reqt.dump(llvm::errs());
           llvm::errs() << "\n";
-          abort();
+          dumpAndAbort();
         }
         if (compareDependentTypes(firstType, secondType) >= 0) {
           llvm::errs() << "Out-of-order type parameters: ";
           reqt.dump(llvm::errs());
           llvm::errs() << "\n";
-          abort();
+          dumpAndAbort();
         }
 
         if (component.empty()) {
@@ -1001,7 +1006,7 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
                        << "is out-of-order: ";
           reqt.dump(llvm::errs());
           llvm::errs() << "\n";
-          abort();
+          dumpAndAbort();
         }
 
         component.push_back(secondType);
@@ -1010,7 +1015,7 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
           llvm::errs() << "Right hand side is not reduced: ";
           reqt.dump(llvm::errs());
           llvm::errs() << "\n";
-          abort();
+          dumpAndAbort();
         }
 
         if (component.empty()) {
@@ -1019,7 +1024,7 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
           llvm::errs() << "Inconsistent concrete requirement in equiv. class: ";
           reqt.dump(llvm::errs());
           llvm::errs() << "\n";
-          abort();
+          dumpAndAbort();
         }
       }
       break;
@@ -1043,7 +1048,7 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
       llvm::errs() << "Out-of-order left-hand side: ";
       reqt.dump(llvm::errs());
       llvm::errs() << "\n";
-      abort();
+      dumpAndAbort();
     }
 
     // If we have a concrete same-type requirement, we shouldn't have any
@@ -1055,15 +1060,15 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
                      << "any other requirements: ";
         reqt.dump(llvm::errs());
         llvm::errs() << "\n";
-        abort();
+        dumpAndAbort();
       }
     }
 
     if (prevReqt.compare(reqt) >= 0) {
       llvm::errs() << "Out-of-order requirement: ";
       reqt.dump(llvm::errs());
       llvm::errs() << "\n";
-      abort();
+      dumpAndAbort();
     }
   }
 
@@ -1079,11 +1084,11 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
 
     if (protos.size() != canonicalProtos.size()) {
       llvm::errs() << "Redundant conformance requirements in signature\n";
-      abort();
+      dumpAndAbort();
     }
     if (!std::equal(protos.begin(), protos.end(), canonicalProtos.begin())) {
       llvm::errs() << "Out-of-order conformance requirements\n";
-      abort();
+      dumpAndAbort();
     }
   }
 
@@ -1095,7 +1100,7 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
       llvm::errs() << "Reduced type: " << pair.first << "\n";
       llvm::errs() << "Left hand side of first requirement: "
                    << pair.second.front() << "\n";
-      abort();
+      dumpAndAbort();
     }
   }
 }
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -3129,6 +3129,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()) {
diff --git a/lib/AST/RequirementMachine/RequirementLowering.cpp b/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);
diff --git a/test/Sema/moveonly_sendable_legacy.swift b/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 {}
