Handle more cycles with ConcurrentValue inference

Author: DougGregor

lib/AST/Module.cpp

@@ -970,18 +970,18 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
   // If we are recursively checking for implicit conformance of a nominal
   // type to ConcurrentValue, fail without evaluating this request. This
   // squashes cycles.
+  LookupConformanceInModuleRequest request{{this, type, protocol}};
   if (protocol->isSpecificProtocol(KnownProtocolKind::ConcurrentValue)) {
     if (auto nominal = type->getAnyNominal()) {
-      GetImplicitConcurrentValueRequest request{nominal};
-      if (getASTContext().evaluator.hasActiveRequest(request))
+      GetImplicitConcurrentValueRequest icvRequest{nominal};
+      if (getASTContext().evaluator.hasActiveRequest(icvRequest) ||
+          getASTContext().evaluator.hasActiveRequest(request))
         return ProtocolConformanceRef::forInvalid();
     }
   }
 
   return evaluateOrDefault(
-      getASTContext().evaluator,
-      LookupConformanceInModuleRequest{{this, type, protocol}},
-      ProtocolConformanceRef::forInvalid());
+      getASTContext().evaluator, request, ProtocolConformanceRef::forInvalid());
 }
 
 ProtocolConformanceRef

test/Concurrency/concurrent_value_inference.swift

@@ -26,10 +26,46 @@ struct GS2<T> {
 }
 
 func acceptCV<T: ConcurrentValue>(_: T) { }
-// expected-note@-1 3{{where 'T' =}}
+// expected-note@-1 4{{where 'T' =}}
+
+// Example that was triggering circular dependencies.
+struct Signature { }
+struct Data { }
+struct BlockInfo { }
+
+struct Bitcode {
+  let signature: Signature
+  let elements: [BitcodeElement]
+  let blockInfo: [UInt64: BlockInfo]
+}
+
+enum BitcodeElement {
+  struct Block {
+    var id: UInt64
+    var elements: [BitcodeElement]
+  }
+
+  struct Record {
+    enum Payload {
+      case none
+      case array([UInt64])
+      case char6String(String)
+      case blob(Data)
+    }
+
+    var id: UInt64
+    var fields: [UInt64]
+    var payload: Payload
+  }
+
+  case block(Block)
+  case record(Record)
+}
+
 
 func testCV(
-  c1: C1, c2: C2, s1: S1, e1: E1, e2: E2, gs1: GS1<Int>, gs2: GS2<Int>
+  c1: C1, c2: C2, s1: S1, e1: E1, e2: E2, gs1: GS1<Int>, gs2: GS2<Int>,
+  bc: Bitcode
 ) {
   acceptCV(c1) // expected-error{{'C1' conform to 'ConcurrentValue'}}
   acceptCV(c2)
@@ -38,4 +74,7 @@ func testCV(
   acceptCV(e2)
   acceptCV(gs1)
   acceptCV(gs2) // expected-error{{'GS2<Int>' conform to 'ConcurrentValue'}}
+
+  // Note available due to recursive conformance dependencies.
+  acceptCV(bc) // expected-error{{global function 'acceptCV' requires that 'Bitcode' conform to 'ConcurrentValue'}}
 }