Avoid cycles when computing a requirement signature

Replace most remaining uses of isRequirementSignatureComputed by
isRequirementSignatureComputing which uses Evaluator::hasActiveRequest
to detect if the requirements are currently being computed.

Author: xymus

include/swift/AST/Decl.h

@@ -4305,6 +4305,9 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// requirements listed here become entries in the witness table.
   ArrayRef<Requirement> getRequirementSignature() const;
 
+  /// Is the requirement signature currently being computed?
+  bool isComputingRequirementSignature() const;
+
   /// Has the requirement signature been computed yet?
   bool isRequirementSignatureComputed() const {
     return RequirementSignature != nullptr;

include/swift/AST/GenericSignatureBuilder.h

@@ -1056,7 +1056,7 @@ class GenericSignatureBuilder::RequirementSource final
                     WrittenRequirementLoc writtenReqLoc)
     : kind(kind), storageKind(StorageKind::StoredType),
       hasTrailingWrittenRequirementLoc(!writtenReqLoc.isNull()),
-      usesRequirementSignature(protocol->isRequirementSignatureComputed()),
+      usesRequirementSignature(!protocol->isComputingRequirementSignature()),
       parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");

lib/AST/Decl.cpp

@@ -4575,6 +4575,11 @@ ArrayRef<Requirement> ProtocolDecl::getRequirementSignature() const {
                None);
 }
 
+bool ProtocolDecl::isComputingRequirementSignature() const {
+  return getASTContext().evaluator.hasActiveRequest(
+                 RequirementSignatureRequest{const_cast<ProtocolDecl*>(this)});
+}
+
 void ProtocolDecl::setRequirementSignature(ArrayRef<Requirement> requirements) {
   assert(!RequirementSignature && "requirement signature already set");
   if (requirements.empty()) {

lib/AST/GenericSignatureBuilder.cpp

@@ -4107,7 +4107,7 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
   // Use the requirement signature to avoid rewalking the entire protocol.  This
   // cannot compute the requirement signature directly, because that may be
   // infinitely recursive: this code is also used to construct it.
-  if (proto->isRequirementSignatureComputed()) {
+  if (!proto->isComputingRequirementSignature()) {
     auto innerSource =
       FloatingRequirementSource::viaProtocolRequirement(source, proto,
                                                         /*inferred=*/false);