Revert "Sema: Split up gatherConstraints() into gatherAllConstraints() and gatherNearbyConstraints()"

This reverts commit 2230c3a.

Author: slavapestov

include/swift/Sema/ConstraintGraph.h

@@ -300,18 +300,25 @@ class ConstraintGraph {
   /// to a type variable.
   void introduceToInference(TypeVariableType *typeVar, Type fixedType);
 
-  /// Gather constraints associated with all of the variables within the
-  /// same equivalence class as the given type variable, as well as its
-  /// immediate fixed bindings.
-  llvm::TinyPtrVector<Constraint *>
-  gatherAllConstraints(TypeVariableType *typeVar);
+  /// Describes which constraints \c gatherConstraints should gather.
+  enum class GatheringKind {
+    /// Gather constraints associated with all of the variables within the
+    /// same equivalence class as the given type variable, as well as its
+    /// immediate fixed bindings.
+    EquivalenceClass,
+    /// Gather all constraints that mention this type variable or type variables
+    /// that it is a fixed binding of. Unlike EquivalenceClass, this looks
+    /// through transitive fixed bindings. This can be used to find all the
+    /// constraints that may be affected when binding a type variable.
+    AllMentions,
+  };
 
-  /// Gather all constraints that mention this type variable or type variables
-  /// that it is a fixed binding of. Unlike EquivalenceClass, this looks
-  /// through transitive fixed bindings. This can be used to find all the
-  /// constraints that may be affected when binding a type variable.
+  /// Gather the set of constraints that involve the given type variable,
+  /// i.e., those constraints that will be affected when the type variable
+  /// gets merged or bound to a fixed type.
   llvm::TinyPtrVector<Constraint *>
-  gatherNearbyConstraints(TypeVariableType *typeVar,
+  gatherConstraints(TypeVariableType *typeVar,
+                    GatheringKind kind,
                     llvm::function_ref<bool(Constraint *)> acceptConstraint =
                         [](Constraint *constraint) { return true; });
 

lib/Sema/CSOptimizer.cpp

@@ -152,8 +152,8 @@ NullablePtr<Constraint> getApplicableFnConstraint(ConstraintGraph &CG,
   if (!boundVar)
     return nullptr;
 
-  auto constraints = CG.gatherNearbyConstraints(
-      boundVar,
+  auto constraints = CG.gatherConstraints(
+      boundVar, ConstraintGraph::GatheringKind::EquivalenceClass,
       [](Constraint *constraint) {
         return constraint->getKind() == ConstraintKind::ApplicableFunction;
       });
@@ -1172,8 +1172,8 @@ selectBestBindingDisjunction(ConstraintSystem &cs,
     if (!firstBindDisjunction)
       firstBindDisjunction = disjunction;
 
-    auto constraints = cs.getConstraintGraph().gatherNearbyConstraints(
-        typeVar,
+    auto constraints = cs.getConstraintGraph().gatherConstraints(
+        typeVar, ConstraintGraph::GatheringKind::EquivalenceClass,
         [](Constraint *constraint) {
           return constraint->getKind() == ConstraintKind::Conversion;
         });

lib/Sema/CSSimplify.cpp

@@ -15793,8 +15793,8 @@ ConstraintSystem::addKeyPathApplicationRootConstraint(Type root, ConstraintLocat
   if (!typeVar)
     return;
 
-  auto constraints = CG.gatherNearbyConstraints(
-      typeVar,
+  auto constraints = CG.gatherConstraints(
+      typeVar, ConstraintGraph::GatheringKind::EquivalenceClass,
       [&keyPathExpr](Constraint *constraint) -> bool {
         if (constraint->getKind() != ConstraintKind::KeyPath)
           return false;

lib/Sema/CSSolver.cpp

@@ -1297,8 +1297,8 @@ ConstraintSystem::findConstraintThroughOptionals(
   while (visitedVars.insert(rep).second) {
     // Look for a disjunction that binds this type variable to an overload set.
     TypeVariableType *optionalObjectTypeVar = nullptr;
-    auto constraints = getConstraintGraph().gatherNearbyConstraints(
-        rep,
+    auto constraints = getConstraintGraph().gatherConstraints(
+        rep, ConstraintGraph::GatheringKind::EquivalenceClass,
         [&](Constraint *match) {
           // If we have an "optional object of" constraint, we may need to
           // look through it to find the constraint we're looking for.
@@ -1906,8 +1906,9 @@ void DisjunctionChoice::propagateConversionInfo(ConstraintSystem &cs) const {
     }
   }
 
-  auto constraints = cs.CG.gatherNearbyConstraints(
+  auto constraints = cs.CG.gatherConstraints(
       typeVar,
+      ConstraintGraph::GatheringKind::EquivalenceClass,
       [](Constraint *constraint) -> bool {
         switch (constraint->getKind()) {
         case ConstraintKind::Conversion:

lib/Sema/ConstraintGraph.cpp

@@ -552,11 +552,18 @@ void ConstraintGraph::retractBindings(TypeVariableType *typeVar,
 
 #pragma mark Algorithms
 
+/// Perform a depth-first search.
+///
+/// \param cg The constraint graph.
+/// \param typeVar The type variable we're searching from.
+/// \param visitConstraint Called before considering a constraint.
+/// \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::TinyPtrVector<Constraint *> &constraints,
     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.
@@ -570,8 +577,11 @@ static void depthFirstSearch(
   // Local function to visit adjacent type variables.
   auto visitAdjacencies = [&](ArrayRef<TypeVariableType *> adjTypeVars) {
     for (auto adj : adjTypeVars) {
-      if (adj != typeVar)
-        depthFirstSearch(cg, adj, typeVars, constraints, visitedConstraints);
+      if (adj == typeVar)
+        continue;
+
+      // Recurse into this node.
+      depthFirstSearch(cg, adj, visitConstraint, typeVars, visitedConstraints);
     }
   };
 
@@ -582,7 +592,7 @@ static void depthFirstSearch(
     if (!visitedConstraints.insert(constraint).second)
       continue;
 
-    constraints.push_back(constraint);
+    visitConstraint(constraint);
   }
 
   // Visit all of the other nodes in the equivalence class.
@@ -601,22 +611,28 @@ static void depthFirstSearch(
   visitAdjacencies(node.getReferencedVars());
 }
 
-llvm::TinyPtrVector<Constraint *> ConstraintGraph::gatherAllConstraints(
-    TypeVariableType *typeVar) {
+llvm::TinyPtrVector<Constraint *> ConstraintGraph::gatherConstraints(
+    TypeVariableType *typeVar, GatheringKind kind,
+    llvm::function_ref<bool(Constraint *)> acceptConstraintFn) {
   llvm::TinyPtrVector<Constraint *> constraints;
   llvm::SmallPtrSet<TypeVariableType *, 4> typeVars;
   llvm::SmallPtrSet<Constraint *, 8> visitedConstraints;
 
-  depthFirstSearch(*this, typeVar, typeVars, constraints, visitedConstraints);
-  return constraints;
-}
+  if (kind == GatheringKind::AllMentions) {
+    // If we've been asked for "all mentions" of a type variable, search for
+    // constraints involving both it and its fixed bindings.
+    depthFirstSearch(
+        *this, typeVar,
+        [&](Constraint *constraint) {
+          if (acceptConstraintFn(constraint))
+            constraints.push_back(constraint);
+        },
+        typeVars, visitedConstraints);
+    return constraints;
+  }
 
-llvm::TinyPtrVector<Constraint *> ConstraintGraph::gatherNearbyConstraints(
-    TypeVariableType *typeVar, 
-    llvm::function_ref<bool(Constraint *)> acceptConstraintFn) {
-  llvm::TinyPtrVector<Constraint *> constraints;
-  llvm::SmallPtrSet<TypeVariableType *, 4> typeVars;
-  llvm::SmallPtrSet<Constraint *, 8> visitedConstraints;
+  // Otherwise only search in the type var's equivalence class and immediate
+  // fixed bindings.
 
   // Local function to add constraints.
   auto addTypeVarConstraints = [&](TypeVariableType *adjTypeVar) {

lib/Sema/ConstraintSystem.cpp

@@ -267,7 +267,8 @@ void ConstraintSystem::assignFixedType(TypeVariableType *typeVar, Type type,
 void ConstraintSystem::addTypeVariableConstraintsToWorkList(
        TypeVariableType *typeVar) {
   // Activate the constraints affected by a change to this type variable.
-  for (auto *constraint : CG.gatherAllConstraints(typeVar))
+  auto gatheringKind = ConstraintGraph::GatheringKind::AllMentions;
+  for (auto *constraint : CG.gatherConstraints(typeVar, gatheringKind))
     if (!constraint->isActive())
       activateConstraint(constraint);
 }

lib/Sema/TypeOfReference.cpp

@@ -2044,8 +2044,8 @@ void ConstraintSystem::bindOverloadType(
       increaseScore(SK_KeyPathSubscript, locator);
 
       auto boundTypeVar = boundType->castTo<TypeVariableType>();
-      auto constraints = getConstraintGraph().gatherNearbyConstraints(
-          boundTypeVar,
+      auto constraints = getConstraintGraph().gatherConstraints(
+          boundTypeVar, ConstraintGraph::GatheringKind::EquivalenceClass,
           [](Constraint *constraint) {
             return constraint->getKind() == ConstraintKind::ApplicableFunction;
           });