Merge pull request swiftlang#71764 from slavapestov/ncgenerics-xfail

Fix some NoncopyableGenerics test failures and mark remaining as XFAIL

Author: slavapestov

lib/AST/Decl.cpp

@@ -1301,9 +1301,10 @@ bool GenericContext::isComputingGenericSignature() const {
 
 /// If we hit a cycle while building the generic signature, we can't return
 /// nullptr, since this breaks invariants elsewhere. Instead, build a dummy
-/// signature with no requirements.
+/// signature where everything is Copyable and Escapable, to avoid spurious
+/// downstream diagnostics concerning move-only types.
 static GenericSignature getPlaceholderGenericSignature(
-    const DeclContext *DC) {
+    ASTContext &ctx, const DeclContext *DC) {
   SmallVector<GenericParamList *, 2> gpLists;
   DC->forEachGenericContext([&](GenericParamList *genericParams) {
     gpLists.push_back(genericParams);
@@ -1316,23 +1317,32 @@ static GenericSignature getPlaceholderGenericSignature(
   for (unsigned i : indices(gpLists))
     gpLists[i]->setDepth(i);
 
-  SmallVector<GenericTypeParamType *, 2> result;
-  for (auto *genericParams : gpLists) {
-    for (auto *genericParam : *genericParams) {
-      result.push_back(genericParam->getDeclaredInterfaceType()
-                                   ->castTo<GenericTypeParamType>());
+  SmallVector<GenericTypeParamType *, 2> genericParams;
+  SmallVector<Requirement, 2> requirements;
+
+  for (auto *gpList : gpLists) {
+    for (auto *genericParam : *gpList) {
+      auto type = genericParam->getDeclaredInterfaceType();
+      genericParams.push_back(type->castTo<GenericTypeParamType>());
+
+      if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+        for (auto ip : InvertibleProtocolSet::full()) {
+          auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
+          requirements.emplace_back(RequirementKind::Conformance, type,
+                                    proto->getDeclaredInterfaceType());
+        }
+      }
     }
   }
 
-  return GenericSignature::get(result, {});
+  return GenericSignature::get(genericParams, requirements);
 }
 
 GenericSignature GenericContext::getGenericSignature() const {
-  // Don't use evaluateOrDefault() here, because getting the 'default value'
-  // is slightly expensive here so we don't want to do it eagerly.
-  return getASTContext().evaluator(
+  auto &ctx = getASTContext();
+  return ctx.evaluator(
       GenericSignatureRequest{const_cast<GenericContext *>(this)},
-      [this]() { return getPlaceholderGenericSignature(this); });
+      [&ctx, this]() { return getPlaceholderGenericSignature(ctx, this); });
 }
 
 GenericEnvironment *GenericContext::getGenericEnvironment() const {
@@ -6912,10 +6922,46 @@ ProtocolDecl::getProtocolDependencies() const {
       llvm::None);
 }
 
+/// If we hit a request cycle, give the protocol a requirement signature where
+/// everything is Copyable and Escapable. Otherwise, we'll get spurious
+/// downstream diagnostics concerning move-only types.
+static RequirementSignature getPlaceholderRequirementSignature(
+    const ProtocolDecl *proto) {
+  auto &ctx = proto->getASTContext();
+
+  SmallVector<Requirement, 2> requirements;
+
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    auto add = [&](Type type) {
+      for (auto ip : InvertibleProtocolSet::full()) {
+        auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
+        requirements.emplace_back(RequirementKind::Conformance, type,
+                                  proto->getDeclaredInterfaceType());
+      }
+    };
+
+    add(proto->getSelfInterfaceType());
+
+    for (auto *assocTypeDecl : proto->getAssociatedTypeMembers())
+      add(assocTypeDecl->getDeclaredInterfaceType());
+  }
+
+  // Maintain invariants.
+  llvm::array_pod_sort(requirements.begin(), requirements.end(),
+                       [](const Requirement *lhs, const Requirement *rhs) -> int {
+                         return lhs->compare(*rhs);
+                       });
+
+  return RequirementSignature(ctx.AllocateCopy(requirements),
+                              ArrayRef<ProtocolTypeAlias>());
+}
+
 RequirementSignature ProtocolDecl::getRequirementSignature() const {
-  return evaluateOrDefault(getASTContext().evaluator,
+  return getASTContext().evaluator(
                RequirementSignatureRequest { const_cast<ProtocolDecl *>(this) },
-               RequirementSignature());
+               [this]() {
+                 return getPlaceholderRequirementSignature(this);
+               });
 }
 
 bool ProtocolDecl::isComputingRequirementSignature() const {

lib/AST/NameLookup.cpp

@@ -751,8 +751,6 @@ extInfoRemovingThrownError(AnyFunctionType *fnType) {
 
 /// Remove the thrown error type.
 static CanType removeThrownError(Type type) {
-  ASTContext &ctx = type->getASTContext();
-
   return type.transformRec([](TypeBase *type) -> std::optional<Type> {
     if (auto funcTy = dyn_cast<FunctionType>(type)) {
       if (auto newExtInfo = extInfoRemovingThrownError(funcTy)) {

lib/AST/Requirement.cpp

@@ -346,6 +346,9 @@ void InverseRequirement::expandDefaults(
     ASTContext &ctx,
     ArrayRef<Type> gps,
     SmallVectorImpl<StructuralRequirement> &result) {
+  if (!SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS &&
+      !ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+    return;
 
   SmallVector<ProtocolDecl*, NumInvertibleProtocols> defaults;
   expandDefaults(ctx, /*inverses=*/{}, defaults);

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -746,6 +746,25 @@ AbstractGenericSignatureRequest::evaluate(
   }
 }
 
+/// If completion fails, build a dummy generic signature where everything is
+/// Copyable and Escapable, to avoid spurious downstream diagnostics
+/// concerning move-only types.
+static GenericSignature getPlaceholderGenericSignature(
+    ASTContext &ctx, ArrayRef<GenericTypeParamType *> genericParams) {
+  SmallVector<Requirement, 2> requirements;
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    for (auto param : genericParams) {
+      for (auto ip : InvertibleProtocolSet::full()) {
+        auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
+        requirements.emplace_back(RequirementKind::Conformance, param,
+                                  proto->getDeclaredInterfaceType());
+      }
+    }
+  }
+
+  return GenericSignature::get(genericParams, requirements);
+}
+
 GenericSignatureWithError
 InferredGenericSignatureRequest::evaluate(
         Evaluator &evaluator,
@@ -857,7 +876,8 @@ InferredGenericSignatureRequest::evaluate(
   // generic parameters, as the outer parameters have already been expanded.
   SmallVector<Type, 4> paramTypes;
   if (allowInverses) {
-    paramTypes.append(genericParams.begin() + numOuterParams, genericParams.end());
+    paramTypes.append(genericParams.begin() + numOuterParams,
+                      genericParams.end());
   }
 
   SmallVector<StructuralRequirement, 2> defaults;
@@ -909,8 +929,7 @@ InferredGenericSignatureRequest::evaluate(
                          diag::requirement_machine_completion_rule,
                          rule);
 
-      auto result = GenericSignature::get(genericParams,
-                                          parentSig.getRequirements());
+      auto result = getPlaceholderGenericSignature(ctx, genericParams);
 
       if (rewriteCtx.getDebugOptions().contains(DebugFlags::Timers)) {
         rewriteCtx.endTimer("InferredGenericSignatureRequest");

test/Concurrency/sendable_keypaths.swift

@@ -1,5 +1,7 @@
 // RUN: %target-typecheck-verify-swift -enable-upcoming-feature InferSendableFromCaptures -strict-concurrency=complete
 
+// XFAIL: noncopyable_generics
+
 // REQUIRES: concurrency
 // REQUIRES: asserts
 

test/Concurrency/transfernonsendable_instruction_matching.sil

@@ -1,4 +1,5 @@
 // RUN: %target-sil-opt -transfer-non-sendable -enable-experimental-feature RegionBasedIsolation -strict-concurrency=complete %s -verify -o /dev/null
+// RUN: %target-sil-opt -enable-experimental-feature NoncopyableGenerics -transfer-non-sendable -enable-experimental-feature RegionBasedIsolation -strict-concurrency=complete %s -verify -o /dev/null
 
 // REQUIRES: concurrency
 // REQUIRES: asserts

test/ConstExtraction/ExtractAnnotations.swift

@@ -171,3 +171,5 @@ public struct DeprecatedAnnotations: MyProto {}
 // CHECK-NEXT:    ]
 // CHECK-NEXT:  }
 // CHECK-NEXT:]
+
+// XFAIL: noncopyable_generics

test/ConstExtraction/ExtractCalls.swift

@@ -156,3 +156,6 @@ public struct Bat {
 // CHECK-NEXT:    ]
 // CHECK-NEXT:  }
 // CHECK-NEXT:]
+
+// XFAIL: noncopyable_generics
+

test/ConstExtraction/ExtractConstantsFromMembersAttribute.swift

@@ -65,3 +65,6 @@ enum DirectOnEnum {
 // CHECK:         "kind": "enum",
 // CHECK:         "cases": [
 // CHECK:             "name": "yes"
+
+// XFAIL: noncopyable_generics
+

test/ConstExtraction/ExtractEnums.swift

@@ -227,3 +227,6 @@ public struct Enums: MyProto {
 // CHECK-NEXT:    ]
 // CHECK-NEXT:  }
 // CHECK-NEXT:]
+
+// XFAIL: noncopyable_generics
+