Tiny RequirementMachine fixes

include/swift/AST/ASTContext.h

@@ -1181,6 +1181,11 @@ class ASTContext final {
   rewriting::RequirementMachine *getOrCreateRequirementMachine(
       CanGenericSignature sig);
 
+  /// This is a hack to break cycles. Don't introduce new callers of this
+  /// method.
+  bool isRecursivelyConstructingRequirementMachine(
+      CanGenericSignature sig);
+
   /// Retrieve a generic signature with a single unconstrained type parameter,
   /// like `<T>`.
   CanGenericSignature getSingleGenericParameterSignature() const;

lib/AST/ASTContext.cpp

@@ -1997,6 +1997,22 @@ ASTContext::getOrCreateRequirementMachine(CanGenericSignature sig) {
   return machine;
 }
 
+bool ASTContext::isRecursivelyConstructingRequirementMachine(
+      CanGenericSignature sig) {
+  auto &rewriteCtx = getImpl().TheRewriteContext;
+  if (!rewriteCtx)
+    return false;
+
+  auto arena = getArena(sig);
+  auto &machines = getImpl().getArena(arena).RequirementMachines;
+
+  auto found = machines.find(sig);
+  if (found == machines.end())
+    return false;
+
+  return !found->second->isComplete();
+}
+
 Optional<llvm::TinyPtrVector<ValueDecl *>>
 OverriddenDeclsRequest::getCachedResult() const {
   auto decl = std::get<0>(getStorage());

lib/AST/GenericSignature.cpp

@@ -349,22 +349,36 @@ GenericSignatureImpl::getLocalRequirements(Type depType) const {
     auto rqmResult = computeViaRQM();
     auto gsbResult = computeViaGSB();
 
-    auto typesEqual = [&](Type lhs, Type rhs) {
+    auto typesEqual = [&](Type lhs, Type rhs, bool canonical) {
       if (!lhs || !rhs)
         return !lhs == !rhs;
-      return lhs->isEqual(rhs);
+      if (lhs->isEqual(rhs))
+        return true;
+
+      if (canonical)
+        return false;
+
+      if (getCanonicalTypeInContext(lhs) ==
+          getCanonicalTypeInContext(rhs))
+        return true;
+
+      return false;
     };
 
     auto compare = [&]() {
       // If the types are concrete, we don't care about the rest.
       if (gsbResult.concreteType || rqmResult.concreteType) {
-        if (!typesEqual(gsbResult.concreteType, rqmResult.concreteType))
+        if (!typesEqual(gsbResult.concreteType,
+                        rqmResult.concreteType,
+                        false))
           return false;
 
         return true;
       }
 
-      if (!typesEqual(gsbResult.anchor, rqmResult.anchor))
+      if (!typesEqual(gsbResult.anchor,
+                      rqmResult.anchor,
+                      true))
         return false;
 
       if (gsbResult.layout != rqmResult.layout)
@@ -378,6 +392,11 @@ GenericSignatureImpl::getLocalRequirements(Type depType) const {
       if (lhsProtos != rhsProtos)
         return false;
 
+      if (!typesEqual(gsbResult.superclass,
+                      rqmResult.superclass,
+                      false))
+        return false;
+
       return true;
     };
 
@@ -770,7 +789,11 @@ Type GenericSignatureImpl::getConcreteType(Type type) const {
     auto check = [&]() {
       if (!gsbResult || !rqmResult)
         return !gsbResult == !rqmResult;
-      return gsbResult->isEqual(rqmResult);
+      if (gsbResult->isEqual(rqmResult))
+        return true;
+
+      return (getCanonicalTypeInContext(gsbResult)
+              == getCanonicalTypeInContext(rqmResult));
     };
 
     if (!check()) {

lib/Sema/TypeCheckProtocolInference.cpp

@@ -819,9 +819,14 @@ Type AssociatedTypeInference::computeFixedTypeWitness(
         !conformedProto->inheritsFrom(assocType->getProtocol()))
       continue;
 
-    const auto ty =
-        conformedProto->getGenericSignature()->getCanonicalTypeInContext(
-            structuralTy);
+    auto sig = conformedProto->getGenericSignature();
+
+    // FIXME: The RequirementMachine will assert on re-entrant construction.
+    // We should find a more principled way of breaking this cycle.
+    if (ctx.isRecursivelyConstructingRequirementMachine(sig.getCanonicalSignature()))
+      continue;
+
+    const auto ty = sig->getCanonicalTypeInContext(structuralTy);
 
     // A dependent member type with an identical base and name indicates that
     // the protocol does not same-type constrain it in any way; move on to