RequirementMachine: Add debugging flag to disable re-using requirement machines

Author: slavapestov

include/swift/Basic/LangOptions.h

@@ -549,6 +549,10 @@ namespace swift {
     /// enabled. It can be disabled for debugging and testing.
     bool EnableRequirementMachineLoopNormalization = true;
 
+    /// Enable reuse of requirement machines for minimization. Usually you want
+    /// this enabled. It can be disabled for debugging and testing.
+    bool EnableRequirementMachineReuse = true;
+
     /// Enable experimental, more correct support for opaque result types as
     /// concrete types. This will sometimes fail to produce a convergent
     /// rewrite system.

include/swift/Option/FrontendOptions.td

@@ -368,6 +368,9 @@ def disable_requirement_machine_concrete_contraction : Flag<["-"], "disable-requ
 def disable_requirement_machine_loop_normalization : Flag<["-"], "disable-requirement-machine-loop-normalization">,
   HelpText<"Disable stronger minimization algorithm, for debugging only">;
 
+def disable_requirement_machine_reuse : Flag<["-"], "disable-requirement-machine-reuse">,
+  HelpText<"Disable re-use of requirement machines for minimization, for debugging only">;
+
 def enable_requirement_machine_opaque_archetypes : Flag<["-"], "enable-requirement-machine-opaque-archetypes">,
   HelpText<"Enable more correct opaque archetype support, which is off by default because it might fail to produce a convergent rewrite system">;
 

lib/AST/RequirementMachine/RewriteContext.cpp

@@ -201,13 +201,15 @@ bool RewriteContext::isRecursivelyConstructingRequirementMachine(
 void RewriteContext::installRequirementMachine(
     CanGenericSignature sig,
     std::unique_ptr<RequirementMachine> machine) {
-  auto *machinePtr = machine.release();
+  if (!Context.LangOpts.EnableRequirementMachineReuse)
+    return;
 
-  machinePtr->freeze();
+  auto &entry = Machines[sig];
+  if (entry != nullptr)
+    return;
 
-  auto inserted = Machines.insert(std::make_pair(sig, machinePtr)).second;
-  if (!inserted)
-    delete machinePtr;
+  machine->freeze();
+  entry = machine.release();
 }
 
 /// Implement Tarjan's algorithm to compute strongly-connected components in
@@ -455,22 +457,22 @@ bool RewriteContext::isRecursivelyConstructingRequirementMachine(
           !component->second.ComputedRequirementSignatures);
 }
 
-/// Given a reuirement machine that built the requirement signatures for a
+/// Given a requirement machine that built the requirement signatures for a
 /// protocol connected component, attempt to re-use it for subsequent
 /// queries against the connected component, instead of building a new one
 /// later.
 void RewriteContext::installRequirementMachine(
     const ProtocolDecl *proto,
     std::unique_ptr<RequirementMachine> machine) {
-  auto *machinePtr = machine.release();
-
-  machinePtr->freeze();
+  if (!Context.LangOpts.EnableRequirementMachineReuse)
+    return;
 
   auto &component = getProtocolComponentImpl(proto);
-  if (component.Machine == nullptr)
-    component.Machine = machinePtr;
-  else
-    delete machinePtr;
+  if (component.Machine != nullptr)
+    return;
+
+  machine->freeze();
+  component.Machine = machine.release();
 }
 
 /// We print stats in the destructor, which should get executed at the end of

lib/Frontend/CompilerInvocation.cpp

@@ -1001,6 +1001,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   if (Args.hasArg(OPT_disable_requirement_machine_loop_normalization))
     Opts.EnableRequirementMachineLoopNormalization = false;
 
+  if (Args.hasArg(OPT_disable_requirement_machine_reuse))
+    Opts.EnableRequirementMachineReuse = false;
+
   if (Args.hasArg(OPT_enable_requirement_machine_opaque_archetypes))
     Opts.EnableRequirementMachineOpaqueArchetypes = true;