RequirementMachine: Add upper bound on number of attempts at splitting concrete equivalence classes

Author: slavapestov

include/swift/Basic/LangOptions.h

@@ -525,6 +525,10 @@ namespace swift {
     /// algorithm.
     unsigned RequirementMachineMaxConcreteNesting = 30;
 
+    /// Maximum number of attempts to make when splitting concrete equivalence
+    /// classes.
+    unsigned RequirementMachineMaxSplitConcreteEquivClassAttempts = 2;
+
     /// Enable the new experimental protocol requirement signature minimization
     /// algorithm.
     RequirementMachineMode RequirementMachineProtocolSignatures =

include/swift/Option/FrontendOptions.td

@@ -355,6 +355,12 @@ def requirement_machine_max_concrete_nesting : Joined<["-"], "requirement-machin
   Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
   HelpText<"Set the maximum concrete type nesting depth before giving up">;
 
+def requirement_machine_max_split_concrete_equiv_class_attempts : Joined<["-"], "requirement-machine-max-split-concrete-equiv-class-attempts=">,
+  Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
+  HelpText<"Set the maximum concrete number of attempts at splitting "
+           "concrete equivalence classes before giving up. There should "
+           "never be a reason to change this">;
+
 def disable_requirement_machine_concrete_contraction : Flag<["-"], "disable-requirement-machine-concrete-contraction">,
   HelpText<"Disable preprocessing pass to eliminate conformance requirements "
            "on generic parameters which are made concrete">;

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -275,7 +275,19 @@ static bool shouldSplitConcreteEquivalenceClasses(GenericSignature sig) {
 static void splitConcreteEquivalenceClasses(
     ASTContext &ctx,
     GenericSignature sig,
-    SmallVectorImpl<StructuralRequirement> &requirements) {
+    SmallVectorImpl<StructuralRequirement> &requirements,
+    unsigned &attempt) {
+  unsigned maxAttempts =
+      ctx.LangOpts.RequirementMachineMaxSplitConcreteEquivClassAttempts;
+
+  ++attempt;
+  if (attempt >= maxAttempts) {
+    llvm::errs() << "Splitting concrete equivalence classes did not "
+                 << "reach fixed point after " << attempt << " attempts.\n";
+    llvm::errs() << "Last result: " << sig << "\n";
+    abort();
+  }
+
   requirements.clear();
 
   for (auto req : sig.getRequirements()) {
@@ -428,6 +440,7 @@ AbstractGenericSignatureRequestRQM::evaluate(
     }
   }
 
+  unsigned attempt = 0;
   for (;;) {
     // Heap-allocate the requirement machine to save stack space.
     std::unique_ptr<RequirementMachine> machine(new RequirementMachine(
@@ -448,7 +461,7 @@ AbstractGenericSignatureRequestRQM::evaluate(
 
     if (!errorFlags) {
       if (shouldSplitConcreteEquivalenceClasses(result)) {
-        splitConcreteEquivalenceClasses(ctx, result, requirements);
+        splitConcreteEquivalenceClasses(ctx, result, requirements, attempt);
         continue;
       }
 
@@ -568,6 +581,7 @@ InferredGenericSignatureRequestRQM::evaluate(
     }
   }
 
+  unsigned attempt = 0;
   for (;;) {
     // Heap-allocate the requirement machine to save stack space.
     std::unique_ptr<RequirementMachine> machine(new RequirementMachine(
@@ -599,7 +613,8 @@ InferredGenericSignatureRequestRQM::evaluate(
     auto result = GenericSignature::get(genericParams, minimalRequirements);
     auto errorFlags = machine->getErrors();
 
-    if (ctx.LangOpts.RequirementMachineInferredSignatures ==
+    if (attempt == 0 &&
+        ctx.LangOpts.RequirementMachineInferredSignatures ==
         RequirementMachineMode::Enabled) {
       machine->System.computeRedundantRequirementDiagnostics(errors);
       diagnoseRequirementErrors(ctx, errors, allowConcreteGenericParams);
@@ -608,8 +623,9 @@ InferredGenericSignatureRequestRQM::evaluate(
     // FIXME: Handle allowConcreteGenericParams
 
     if (!errorFlags) {
+      // Check if we need to rebuild the signature.
       if (shouldSplitConcreteEquivalenceClasses(result)) {
-        splitConcreteEquivalenceClasses(ctx, result, requirements);
+        splitConcreteEquivalenceClasses(ctx, result, requirements, attempt);
         continue;
       }
 

lib/Frontend/CompilerInvocation.cpp

@@ -998,6 +998,17 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     }
   }
 
+  if (const Arg *A = Args.getLastArg(OPT_requirement_machine_max_split_concrete_equiv_class_attempts)) {
+    unsigned limit;
+    if (StringRef(A->getValue()).getAsInteger(10, limit)) {
+      Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
+                     A->getAsString(Args), A->getValue());
+      HadError = true;
+    } else {
+      Opts.RequirementMachineMaxSplitConcreteEquivClassAttempts = limit;
+    }
+  }
+
   if (Args.hasArg(OPT_disable_requirement_machine_concrete_contraction))
     Opts.EnableRequirementMachineConcreteContraction = false;