RequirementMachine: Install placeholder requirement signature if completion fails

I did this if there was a request cycle but forgot the other obvious case.

Author: slavapestov

include/swift/AST/RequirementSignature.h

@@ -83,6 +83,9 @@ class RequirementSignature final {
              const PrintOptions &Options = PrintOptions()) const;
   void print(ProtocolDecl *owner, ASTPrinter &Printer,
              const PrintOptions &Opts = PrintOptions()) const;
+
+  static RequirementSignature getPlaceholderRequirementSignature(
+      const ProtocolDecl *proto, GenericSignatureErrors errors);
 };
 
 } // end namespace swift

lib/AST/Decl.cpp

@@ -6858,63 +6858,12 @@ ProtocolDecl::getProtocolDependencies() const {
       std::nullopt);
 }
 
-/// If we hit a request cycle, give the protocol a requirement signature that
-/// still has inherited protocol requirements on Self, and also conformances
-/// to Copyable and Escapable for all associated types. Otherwise, we'll see
-/// invariant violations from the inheritance clause mismatch, as well as
-/// spurious downstream diagnostics concerning move-only types.
-static RequirementSignature getPlaceholderRequirementSignature(
-    const ProtocolDecl *proto) {
-  auto &ctx = proto->getASTContext();
-
-  SmallVector<ProtocolDecl *, 2> inheritedProtos;
-  for (auto *inheritedProto : proto->getInheritedProtocols()) {
-    inheritedProtos.push_back(inheritedProto);
-  }
-
-  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    for (auto ip : InvertibleProtocolSet::full()) {
-      auto *otherProto = ctx.getProtocol(getKnownProtocolKind(ip));
-      inheritedProtos.push_back(otherProto);
-    }
-  }
-
-  ProtocolType::canonicalizeProtocols(inheritedProtos);
-
-  SmallVector<Requirement, 2> requirements;
-
-  for (auto *inheritedProto : inheritedProtos) {
-    requirements.emplace_back(RequirementKind::Conformance,
-                              proto->getSelfInterfaceType(),
-                              inheritedProto->getDeclaredInterfaceType());
-  }
-
-  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    for (auto *assocTypeDecl : proto->getAssociatedTypeMembers()) {
-      for (auto ip : InvertibleProtocolSet::full()) {
-        auto *otherProto = ctx.getProtocol(getKnownProtocolKind(ip));
-        requirements.emplace_back(RequirementKind::Conformance,
-                                  assocTypeDecl->getDeclaredInterfaceType(),
-                                  otherProto->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 getASTContext().evaluator(
-               RequirementSignatureRequest { const_cast<ProtocolDecl *>(this) },
+               RequirementSignatureRequest{const_cast<ProtocolDecl *>(this)},
                [this]() {
-                 return getPlaceholderRequirementSignature(this);
+                 return RequirementSignature::getPlaceholderRequirementSignature(
+                     this, GenericSignatureErrors());
                });
 }
 

lib/AST/GenericSignature.cpp

@@ -1291,6 +1291,59 @@ void GenericSignatureImpl::getRequirementsWithInverses(
   }
 }
 
+/// If we we can't build a requirement signature because of a request cycle or
+/// failure in Knuth-Bendix completion, we give the protocol a requirement
+/// signature that still has inherited protocol requirements on Self, and also
+/// conformances to Copyable and Escapable for all associated types. Otherwise,
+/// we'll see invariant violations from the inheritance clause mismatch, as
+/// well as spurious downstream diagnostics concerning move-only types.
+RequirementSignature RequirementSignature::getPlaceholderRequirementSignature(
+    const ProtocolDecl *proto, GenericSignatureErrors errors) {
+  auto &ctx = proto->getASTContext();
+
+  SmallVector<ProtocolDecl *, 2> inheritedProtos;
+  for (auto *inheritedProto : proto->getInheritedProtocols()) {
+    inheritedProtos.push_back(inheritedProto);
+  }
+
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    for (auto ip : InvertibleProtocolSet::full()) {
+      auto *otherProto = ctx.getProtocol(getKnownProtocolKind(ip));
+      inheritedProtos.push_back(otherProto);
+    }
+  }
+
+  ProtocolType::canonicalizeProtocols(inheritedProtos);
+
+  SmallVector<Requirement, 2> requirements;
+
+  for (auto *inheritedProto : inheritedProtos) {
+    requirements.emplace_back(RequirementKind::Conformance,
+                              proto->getSelfInterfaceType(),
+                              inheritedProto->getDeclaredInterfaceType());
+  }
+
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    for (auto *assocTypeDecl : proto->getAssociatedTypeMembers()) {
+      for (auto ip : InvertibleProtocolSet::full()) {
+        auto *otherProto = ctx.getProtocol(getKnownProtocolKind(ip));
+        requirements.emplace_back(RequirementKind::Conformance,
+                                  assocTypeDecl->getDeclaredInterfaceType(),
+                                  otherProto->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>());
+}
+
 void RequirementSignature::getRequirementsWithInverses(
     ProtocolDecl *owner,
     SmallVector<Requirement, 2> &reqs,

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -342,8 +342,8 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
 
   unsigned attempt = 0;
   for (;;) {
-    for (const auto *proto : component) {
-      auto &requirements = protos[proto];
+    for (const auto *otherProto : component) {
+      auto &requirements = protos[otherProto];
 
       // Preprocess requirements to eliminate conformances on type parameters
       // which are made concrete.
@@ -384,11 +384,13 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
         if (otherProto != proto) {
           ctx.evaluator.cacheOutput(
             RequirementSignatureRequest{const_cast<ProtocolDecl *>(otherProto)},
-            RequirementSignature(GenericSignatureErrorFlags::CompletionFailed));
+            RequirementSignature::getPlaceholderRequirementSignature(
+                otherProto, GenericSignatureErrorFlags::CompletionFailed));
         }
       }
 
-      return RequirementSignature(GenericSignatureErrorFlags::CompletionFailed);
+      return RequirementSignature::getPlaceholderRequirementSignature(
+          proto, GenericSignatureErrorFlags::CompletionFailed);
     }
 
     auto minimalRequirements = machine->computeMinimalProtocolRequirements();

test/Generics/infinite_concrete_type.swift

@@ -1,7 +1,5 @@
 // RUN: %target-typecheck-verify-swift
 
-// XFAIL: noncopyable_generics
-
 class G<T> {}
 
 protocol P1 { // expected-error {{cannot build rewrite system for protocol; concrete nesting limit exceeded}}