Revert "Sema: Simplify depthFirstSearch() a bit now that it only has one caller"

This reverts commit 25ad700.

Author: slavapestov

lib/Sema/ConstraintGraph.cpp

@@ -556,22 +556,25 @@ void ConstraintGraph::retractBindings(TypeVariableType *typeVar,
 ///
 /// \param cg The constraint graph.
 /// \param typeVar The type variable we're searching from.
-/// \param visitConstraint Called before considering a constraint.
+/// \param preVisitNode Called before traversing a node. Must return \c
+/// false when the node has already been visited.
+/// \param visitConstraint Called before considering a constraint. If it
+/// returns \c false, that constraint will be skipped.
 /// \param visitedConstraints Set of already-visited constraints, used
 /// internally to avoid duplicated work.
 static void depthFirstSearch(
     ConstraintGraph &cg,
     TypeVariableType *typeVar,
-    llvm::function_ref<void(Constraint *)> visitConstraint,
-    llvm::SmallPtrSet<TypeVariableType *, 4> &typeVars,
+    llvm::function_ref<bool(TypeVariableType *)> preVisitNode,
+    llvm::function_ref<bool(Constraint *)> visitConstraint,
     llvm::SmallPtrSet<Constraint *, 8> &visitedConstraints) {
   // If we're not looking at this type variable right now because we're
   // solving a conjunction element, don't consider its adjacencies.
   if (!cg.getConstraintSystem().isActiveTypeVariable(typeVar))
     return;
 
   // Visit this node. If we've already seen it, bail out.
-  if (!typeVars.insert(typeVar).second)
+  if (!preVisitNode(typeVar))
     return;
 
   // Local function to visit adjacent type variables.
@@ -581,18 +584,21 @@ static void depthFirstSearch(
         continue;
 
       // Recurse into this node.
-      depthFirstSearch(cg, adj, visitConstraint, typeVars, visitedConstraints);
+      depthFirstSearch(cg, adj, preVisitNode, visitConstraint,
+                       visitedConstraints);
     }
   };
 
-  // Walk all of the constraints associated with this node.
+  // Walk all of the constraints associated with this node to find related
+  // nodes.
   auto &node = cg[typeVar];
   for (auto constraint : node.getConstraints()) {
     // If we've already seen this constraint, skip it.
     if (!visitedConstraints.insert(constraint).second)
       continue;
 
-    visitConstraint(constraint);
+    if (visitConstraint(constraint))
+      visitAdjacencies(constraint->getTypeVariables());
   }
 
   // Visit all of the other nodes in the equivalence class.
@@ -623,11 +629,17 @@ llvm::TinyPtrVector<Constraint *> ConstraintGraph::gatherConstraints(
     // constraints involving both it and its fixed bindings.
     depthFirstSearch(
         *this, typeVar,
+        [&](TypeVariableType *typeVar) {
+          return typeVars.insert(typeVar).second;
+        },
         [&](Constraint *constraint) {
           if (acceptConstraintFn(constraint))
             constraints.push_back(constraint);
+
+          // Don't recurse into the constraint's type variables.
+          return false;
         },
-        typeVars, visitedConstraints);
+        visitedConstraints);
     return constraints;
   }