RequirementMachine: Another cycle-breaking hack for associated type inference

Author: slavapestov

include/swift/AST/ASTContext.h

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

lib/AST/ASTContext.cpp

@@ -2017,6 +2017,11 @@ bool ASTContext::isRecursivelyConstructingRequirementMachine(
   return getRewriteContext().isRecursivelyConstructingRequirementMachine(sig);
 }
 
+bool ASTContext::isRecursivelyConstructingRequirementMachine(
+      const ProtocolDecl *proto) {
+  return getRewriteContext().isRecursivelyConstructingRequirementMachine(proto);
+}
+
 Optional<llvm::TinyPtrVector<ValueDecl *>>
 OverriddenDeclsRequest::getCachedResult() const {
   auto decl = std::get<0>(getStorage());

lib/AST/RequirementMachine/RewriteContext.cpp

@@ -651,6 +651,7 @@ RequirementMachine *RewriteContext::getRequirementMachine(
                    << "machine for:";
       for (auto *proto : component.Protos)
         llvm::errs() << " " << proto->getName();
+      llvm::errs() << "\n";
       abort();
     }
 
@@ -668,6 +669,23 @@ RequirementMachine *RewriteContext::getRequirementMachine(
   return newMachine;
 }
 
+bool RewriteContext::isRecursivelyConstructingRequirementMachine(
+    const ProtocolDecl *proto) {
+  auto found = Protos.find(proto);
+  if (found == Protos.end())
+    return false;
+
+  auto component = Components.find(found->second.ComponentID);
+  if (component == Components.end())
+    return false;
+
+  if (!component->second.Machine ||
+      component->second.Machine->isComplete())
+    return false;
+
+  return true;
+}
+
 /// We print stats in the destructor, which should get executed at the end of
 /// a compilation job.
 RewriteContext::~RewriteContext() {

lib/AST/RequirementMachine/RewriteContext.h

@@ -180,6 +180,7 @@ class RewriteContext final {
   bool isRecursivelyConstructingRequirementMachine(CanGenericSignature sig);
 
   RequirementMachine *getRequirementMachine(const ProtocolDecl *proto);
+  bool isRecursivelyConstructingRequirementMachine(const ProtocolDecl *proto);
 
   ~RewriteContext();
 };

lib/Sema/TypeCheckProtocol.cpp

@@ -4562,19 +4562,29 @@ CheckTypeWitnessResult
 swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
                         const NormalProtocolConformance *Conf,
                         SubstOptions options) {
+  auto &ctx = assocType->getASTContext();
+
   if (type->hasError())
-    return ErrorType::get(assocType->getASTContext());
+    return ErrorType::get(ctx);
 
   const auto proto = Conf->getProtocol();
   const auto dc = Conf->getDeclContext();
-  const auto genericSig = proto->getGenericSignature();
+  const auto sig = proto->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()) ||
+      ctx.isRecursivelyConstructingRequirementMachine(proto) ||
+      proto->isComputingRequirementSignature())
+    return ErrorType::get(ctx);
+
   const auto depTy = DependentMemberType::get(proto->getSelfInterfaceType(),
                                               assocType);
 
   Type contextType = type->hasTypeParameter() ? dc->mapTypeIntoContext(type)
                                               : type;
 
-  if (auto superclass = genericSig->getSuperclassBound(depTy)) {
+  if (auto superclass = sig->getSuperclassBound(depTy)) {
     if (superclass->hasTypeParameter()) {
       // Replace type parameters with other known or tentative type witnesses.
       superclass = superclass.subst(
@@ -4596,7 +4606,7 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
   auto *module = dc->getParentModule();
 
   // Check protocol conformances.
-  for (const auto reqProto : genericSig->getRequiredProtocols(depTy)) {
+  for (const auto reqProto : sig->getRequiredProtocols(depTy)) {
     if (module->lookupConformance(contextType, reqProto)
             .isInvalid())
       return CheckTypeWitnessResult(reqProto->getDeclaredInterfaceType());
@@ -4617,7 +4627,7 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
     }
   }
 
-  if (genericSig->requiresClass(depTy) &&
+  if (sig->requiresClass(depTy) &&
       !contextType->satisfiesClassConstraint())
     return CheckTypeWitnessResult(module->getASTContext().getAnyObjectType());
 

lib/Sema/TypeCheckProtocolInference.cpp

@@ -819,6 +819,7 @@ Type AssociatedTypeInference::computeFixedTypeWitness(
     // 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()) ||
+        ctx.isRecursivelyConstructingRequirementMachine(conformedProto) ||
         conformedProto->isComputingRequirementSignature())
       continue;