Sema: Change a few fields of PotentialBindings from SmallDenseSet to SmallVector

These are not going to have duplicates by construction.

Author: slavapestov

include/swift/Sema/CSBindings.h

@@ -233,18 +233,17 @@ struct PotentialBindings {
   /// bindings (contained in the binding type e.g. `Foo<$T0>`), or
   /// reachable through subtype/conversion  relationship e.g.
   /// `$T0 subtype of $T1` or `$T0 arg conversion $T1`.
-  llvm::SmallDenseSet<std::pair<TypeVariableType *, Constraint *>, 2>
-      AdjacentVars;
-
-  ASTNode AssociatedCodeCompletionToken = ASTNode();
+  llvm::SmallVector<std::pair<TypeVariableType *, Constraint *>, 2> AdjacentVars;
 
   /// A set of all not-yet-resolved type variables this type variable
   /// is a subtype of, supertype of or is equivalent to. This is used
   /// to determine ordering inside of a chain of subtypes to help infer
   /// transitive bindings  and protocol requirements.
-  llvm::SmallSetVector<std::pair<TypeVariableType *, Constraint *>, 4> SubtypeOf;
-  llvm::SmallSetVector<std::pair<TypeVariableType *, Constraint *>, 4> SupertypeOf;
-  llvm::SmallSetVector<std::pair<TypeVariableType *, Constraint *>, 4> EquivalentTo;
+  llvm::SmallVector<std::pair<TypeVariableType *, Constraint *>, 4> SubtypeOf;
+  llvm::SmallVector<std::pair<TypeVariableType *, Constraint *>, 4> SupertypeOf;
+  llvm::SmallVector<std::pair<TypeVariableType *, Constraint *>, 4> EquivalentTo;
+
+  ASTNode AssociatedCodeCompletionToken = ASTNode();
 
   /// Add a potential binding to the list of bindings,
   /// coalescing supertype bounds when we are able to compute the meet.

lib/Sema/CSBindings.cpp

@@ -1646,8 +1646,9 @@ PotentialBindings::inferFromRelational(ConstraintSystem &CS,
     findInferableTypeVars(second, typeVars);
 
     if (typeVars.erase(TypeVar)) {
-      for (auto *typeVar : typeVars)
-        AdjacentVars.insert({typeVar, constraint});
+      for (auto *typeVar : typeVars) {
+        AdjacentVars.emplace_back(typeVar, constraint);
+      }
     }
 
     // Infer a binding from `inout $T <convertible to> Unsafe*Pointer<...>?`.
@@ -1772,7 +1773,7 @@ PotentialBindings::inferFromRelational(ConstraintSystem &CS,
       // Add all type variables encountered in the type except
       // to the current type variable.
       if (var != TypeVar) {
-        AdjacentVars.insert({var, constraint});
+        AdjacentVars.emplace_back(var, constraint);
         continue;
       }
 
@@ -1833,26 +1834,26 @@ PotentialBindings::inferFromRelational(ConstraintSystem &CS,
     case ConstraintKind::ArgumentConversion:
     case ConstraintKind::OperatorArgumentConversion: {
       if (kind == AllowedBindingKind::Subtypes) {
-        SubtypeOf.insert({bindingTypeVar, constraint});
+        SubtypeOf.emplace_back(bindingTypeVar, constraint);
       } else {
         assert(kind == AllowedBindingKind::Supertypes);
-        SupertypeOf.insert({bindingTypeVar, constraint});
+        SupertypeOf.emplace_back(bindingTypeVar, constraint);
       }
 
-      AdjacentVars.insert({bindingTypeVar, constraint});
+      AdjacentVars.emplace_back(bindingTypeVar, constraint);
       break;
     }
 
     case ConstraintKind::Bind:
     case ConstraintKind::BindParam:
     case ConstraintKind::Equal: {
-      EquivalentTo.insert({bindingTypeVar, constraint});
-      AdjacentVars.insert({bindingTypeVar, constraint});
+      EquivalentTo.emplace_back(bindingTypeVar, constraint);
+      AdjacentVars.emplace_back(bindingTypeVar, constraint);
       break;
     }
 
     case ConstraintKind::UnresolvedMemberChainBase: {
-      EquivalentTo.insert({bindingTypeVar, constraint});
+      EquivalentTo.emplace_back(bindingTypeVar, constraint);
 
       // Don't record adjacency between base and result types,
       // this is just an auxiliary constraint to enforce ordering.
@@ -1864,8 +1865,9 @@ PotentialBindings::inferFromRelational(ConstraintSystem &CS,
       // an un-inferred optional is adjacent to a type
       // variable that presents such optional (`bindingTypeVar`
       // in this case).
-      if (kind == AllowedBindingKind::Supertypes)
-        AdjacentVars.insert({bindingTypeVar, constraint});
+      if (kind == AllowedBindingKind::Supertypes) {
+        AdjacentVars.emplace_back(bindingTypeVar, constraint);
+      }
       break;
     }
 
@@ -2088,33 +2090,34 @@ void PotentialBindings::retract(ConstraintSystem &CS,
                       }),
       Bindings.end());
 
-  {
-    llvm::SmallPtrSet<TypeVariableType *, 2> unviable;
-    for (const auto &adjacent : AdjacentVars) {
-      if (adjacent.second == constraint)
-        unviable.insert(adjacent.first);
-    }
-
-    for (auto *adjacentVar : unviable)
-      AdjacentVars.erase(std::make_pair(adjacentVar, constraint));
-  }
-
-  auto isMatchingConstraint = [&constraint](Constraint *existing) {
-    return existing == constraint;
-  };
-
-  DelayedBy.erase(llvm::remove_if(DelayedBy, isMatchingConstraint),
-                  DelayedBy.end());
+  DelayedBy.erase(
+      llvm::remove_if(DelayedBy,
+                      [&constraint](Constraint *existing) {
+                        return existing == constraint;
+                      }),
+      DelayedBy.end());
 
   auto hasMatchingSource =
       [&constraint](
           const std::pair<TypeVariableType *, Constraint *> &adjacency) {
         return adjacency.second == constraint;
       };
 
-  SubtypeOf.remove_if(hasMatchingSource);
-  SupertypeOf.remove_if(hasMatchingSource);
-  EquivalentTo.remove_if(hasMatchingSource);
+  AdjacentVars.erase(
+    llvm::remove_if(AdjacentVars, hasMatchingSource),
+    AdjacentVars.end());
+
+  SubtypeOf.erase(
+    llvm::remove_if(SubtypeOf, hasMatchingSource),
+    SubtypeOf.end());
+
+  SupertypeOf.erase(
+    llvm::remove_if(SupertypeOf, hasMatchingSource),
+    SupertypeOf.end());
+
+  EquivalentTo.erase(
+    llvm::remove_if(EquivalentTo, hasMatchingSource),
+    EquivalentTo.end());
 }
 
 void PotentialBindings::reset() {