Revert "[Constraint graph] Reinstate the adjacencies of constraint graph nodes."

This reverts commit cf1732c.
With `gatherConstraints` no longer visiting
adjacencies, we no longer need to maintain the
adjacency info.

Author: hamishknight

lib/Sema/ConstraintGraph.cpp

@@ -128,74 +128,6 @@ void ConstraintGraphNode::removeConstraint(Constraint *constraint) {
   Constraints.pop_back();
 }
 
-ConstraintGraphNode::Adjacency &
-ConstraintGraphNode::getAdjacency(TypeVariableType *typeVar) {
-  assert(typeVar != TypeVar && "Cannot be adjacent to oneself");
-
-  // Look for existing adjacency information.
-  auto pos = AdjacencyInfo.find(typeVar);
-
-  if (pos != AdjacencyInfo.end())
-    return pos->second;
-
-  // If we weren't already adjacent to this type variable, add it to the
-  // list of adjacencies.
-  pos = AdjacencyInfo.insert(
-          { typeVar, { static_cast<unsigned>(Adjacencies.size()), 0 } })
-         .first;
-  Adjacencies.push_back(typeVar);
-  return pos->second;
-}
-
-void ConstraintGraphNode::modifyAdjacency(
-       TypeVariableType *typeVar,
-       llvm::function_ref<void(Adjacency& adj)> modify) {
-   // Find the adjacency information.
-  auto pos = AdjacencyInfo.find(typeVar);
-  assert(pos != AdjacencyInfo.end() && "Type variables not adjacent");
-  assert(Adjacencies[pos->second.Index] == typeVar && "Mismatched adjacency");
-
-  // Perform the modification .
-  modify(pos->second);
-
-  // If the adjacency is not empty, leave the information in there.
-  if (!pos->second.empty())
-    return;
-
-  // Remove this adjacency from the mapping.
-  unsigned index = pos->second.Index;
-  AdjacencyInfo.erase(pos);
-
-  // If this adjacency is last in the vector, just pop it off.
-  unsigned lastIndex = Adjacencies.size()-1;
-  if (index == lastIndex) {
-    Adjacencies.pop_back();
-    return;
-  }
-
-  // This adjacency is somewhere in the middle; swap it with the last
-  // adjacency so we can remove the adjacency from the vector in O(1) time
-  // rather than O(n) time.
-  auto lastTypeVar = Adjacencies[lastIndex];
-  Adjacencies[index] = lastTypeVar;
-  AdjacencyInfo[lastTypeVar].Index = index;
-  Adjacencies.pop_back();
-}
-
-void ConstraintGraphNode::addAdjacency(TypeVariableType *typeVar) {
-  auto &adjacency = getAdjacency(typeVar);
-
-  // Bump the degree of the adjacency.
-  ++adjacency.NumConstraints;
-}
-
-void ConstraintGraphNode::removeAdjacency(TypeVariableType *typeVar) {
-  modifyAdjacency(typeVar, [](Adjacency &adj) {
-    assert(adj.NumConstraints > 0 && "No adjacency to remove?");
-    --adj.NumConstraints;
-  });
-}
-
 void ConstraintGraphNode::addToEquivalenceClass(
        ArrayRef<TypeVariableType *> typeVars) {
   assert(TypeVar == TypeVar->getImpl().getRepresentative(nullptr) &&
@@ -326,80 +258,52 @@ void ConstraintGraph::removeNode(TypeVariableType *typeVar) {
   TypeVariables.pop_back();
 }
 
-/// Enumerate the adjacency edges for the given constraint.
-static void enumerateAdjacencies(
-    Constraint *constraint,
-    llvm::function_ref<void(TypeVariableType *, TypeVariableType *)> visitor) {
-  // Don't record adjacencies for one-way constraints.
-  if (constraint->isOneWayConstraint())
-    return;
-
-  // O(N^2) update for all of the adjacent type variables.
+void ConstraintGraph::addConstraint(Constraint *constraint) {
+  // For the nodes corresponding to each type variable...
   auto referencedTypeVars = constraint->getTypeVariables();
   for (auto typeVar : referencedTypeVars) {
-    for (auto otherTypeVar : referencedTypeVars) {
-      if (typeVar == otherTypeVar)
-        continue;
+    // Find the node for this type variable.
+    auto &node = (*this)[typeVar];
 
-      visitor(typeVar, otherTypeVar);
-    }
+    // Note the constraint within the node for that type variable.
+    node.addConstraint(constraint);
   }
-}
 
-void ConstraintGraph::addConstraint(Constraint *constraint) {
-  // Record the change, if there are active scopes.
-  if (ActiveScope) {
-    Changes.push_back(Change::addedConstraint(constraint));
-  }
-
-  if (constraint->getTypeVariables().empty()) {
-    // A constraint that doesn't reference any type variables is orphaned;
-    // track it as such.
+  // If the constraint doesn't reference any type variables, it's orphaned;
+  // track it as such.
+  if (referencedTypeVars.empty()) {
     OrphanedConstraints.push_back(constraint);
-    return;
-  }
-
-  // Record this constraint in each type variable.
-  for (auto typeVar : constraint->getTypeVariables()) {
-    (*this)[typeVar].addConstraint(constraint);
   }
 
-  // Record adjacencies.
-  enumerateAdjacencies(constraint,
-                       [&](TypeVariableType *lhs, TypeVariableType *rhs) {
-    assert(lhs != rhs);
-    (*this)[lhs].addAdjacency(rhs);
-  });
+  // Record the change, if there are active scopes.
+  if (ActiveScope)
+    Changes.push_back(Change::addedConstraint(constraint));
 }
 
 void ConstraintGraph::removeConstraint(Constraint *constraint) {
-  // Record the change, if there are active scopes.
-  if (ActiveScope)
-    Changes.push_back(Change::removedConstraint(constraint));
+  // For the nodes corresponding to each type variable...
+  auto referencedTypeVars = constraint->getTypeVariables();
+  for (auto typeVar : referencedTypeVars) {
+    // Find the node for this type variable.
+    auto &node = (*this)[typeVar];
+
+    // Remove the constraint.
+    node.removeConstraint(constraint);
+  }
 
-  if (constraint->getTypeVariables().empty()) {
-    // A constraint that doesn't reference any type variables is orphaned;
-    // remove it from the list of orphaned constraints.
+  // If this is an orphaned constraint, remove it from the list.
+  if (referencedTypeVars.empty()) {
     auto known = std::find(OrphanedConstraints.begin(),
                            OrphanedConstraints.end(),
                            constraint);
     assert(known != OrphanedConstraints.end() && "missing orphaned constraint");
     *known = OrphanedConstraints.back();
     OrphanedConstraints.pop_back();
-    return;
   }
 
-  // Remove the constraint from each type variable.
-  for (auto typeVar : constraint->getTypeVariables()) {
-    (*this)[typeVar].removeConstraint(constraint);
-  }
-
-  // Remove all adjacencies for all type variables.
-  enumerateAdjacencies(constraint,
-                       [&](TypeVariableType *lhs, TypeVariableType *rhs) {
-    assert(lhs != rhs);
-    (*this)[lhs].removeAdjacency(rhs);
-  });
+  // Record the change, if there are active scopes.
+  if (ActiveScope)
+    Changes.push_back(Change::removedConstraint(constraint));
 }
 
 void ConstraintGraph::mergeNodes(TypeVariableType *typeVar1, 
@@ -1336,28 +1240,6 @@ void ConstraintGraphNode::print(llvm::raw_ostream &out, unsigned indent,
     }
   }
 
- if (!Adjacencies.empty()) {
-   out.indent(indent + 2);
-   out << "Adjacencies:";
-   SmallVector<TypeVariableType *, 4> sortedAdjacencies(Adjacencies.begin(),
-                                                        Adjacencies.end());
-   std::sort(sortedAdjacencies.begin(), sortedAdjacencies.end(),
-             [](TypeVariableType *lhs, TypeVariableType *rhs) {
-               return lhs->getID() < rhs->getID();
-             });
-   for (auto adj : sortedAdjacencies) {
-     out << ' ';
-     adj->print(out, PO);
-
-     const auto info = AdjacencyInfo.lookup(adj);
-     auto degree = info.NumConstraints;
-     if (degree > 1) {
-       out << " (" << degree << ")";
-     }
-   }
-   out << "\n";
- }
-
   // Print fixed bindings.
   if (!FixedBindings.empty()) {
     out.indent(indent + 2);
@@ -1527,69 +1409,6 @@ void ConstraintGraphNode::verify(ConstraintGraph &cg) {
     requireSameValue(info.first, Constraints[info.second],
                      "constraint map provides wrong index into vector");
   }
-
-  // Verify that the adjacency map/vector haven't gotten out of sync.
-  requireSameValue(Adjacencies.size(), AdjacencyInfo.size(),
-                   "adjacency vector and map have different sizes");
-  for (auto info : AdjacencyInfo) {
-    require(info.second.Index < Adjacencies.size(),
-            "adjacency index out-of-range");
-    requireSameValue(info.first, Adjacencies[info.second.Index],
-                     "adjacency map provides wrong index into vector");
-    require(!info.second.empty(),
-            "adjacency information should have been removed");
-    require(info.second.NumConstraints <= Constraints.size(),
-            "adjacency information has higher degree than # of constraints");
-  }
-
-  // Based on the constraints we have, build up a representation of what
-  // we expect the adjacencies to look like.
-  llvm::DenseMap<TypeVariableType *, unsigned> expectedAdjacencies;
-  for (auto constraint : Constraints) {
-    if (constraint->isOneWayConstraint())
-      continue;
-
-    for (auto adjTypeVar : constraint->getTypeVariables()) {
-      if (adjTypeVar == TypeVar)
-        continue;
-
-      ++expectedAdjacencies[adjTypeVar];
-    }
-  }
-
-  // Make sure that the adjacencies we expect are the adjacencies we have.
-  PrintOptions PO;
-  PO.PrintTypesForDebugging = true;
-  for (auto adj : expectedAdjacencies) {
-    auto knownAdj = AdjacencyInfo.find(adj.first);
-    requireWithContext(knownAdj != AdjacencyInfo.end(),
-                       "missing adjacency information for type variable",
-                       [&] {
-      llvm::dbgs() << "  type variable=" << adj.first->getString(PO) << 'n';
-    });
-
-    requireWithContext(adj.second == knownAdj->second.NumConstraints,
-                       "wrong number of adjacencies for type variable",
-                       [&] {
-       llvm::dbgs() << "  type variable=" << adj.first->getString(PO)
-                    << " (" << adj.second << " vs. "
-                    << knownAdj->second.NumConstraints
-                    << ")\n";
-     });
-  }
-
-  if (AdjacencyInfo.size() != expectedAdjacencies.size()) {
-    // The adjacency information has something extra in it. Find the
-    // extraneous type variable.
-    for (auto adj : AdjacencyInfo) {
-      requireWithContext(AdjacencyInfo.count(adj.first) > 0,
-                         "extraneous adjacency info for type variable",
-                         [&] {
-        llvm::dbgs() << "  type variable=" << adj.first->getString(PO) << '\n';
-      });
-    }
-  }
-
 #undef requireSameValue
 #undef requireWithContext
 #undef require

lib/Sema/ConstraintGraph.h

@@ -46,20 +46,6 @@ class ConstraintSystem;
 
 /// A single node in the constraint graph, which represents a type variable.
 class ConstraintGraphNode {
-  /// Describes information about an adjacency between two type variables.
-  struct Adjacency {
-    /// Index into the vector of adjacent type variables, \c Adjacencies.
-    unsigned Index;
-
-    /// The number of constraints that link this type variable to the
-    /// enclosing node.
-    unsigned NumConstraints;
-
-    bool empty() const {
-      return NumConstraints == 0;
-    }
-  };
-
 public:
   explicit ConstraintGraphNode(TypeVariableType *typeVar) : TypeVar(typeVar) { }
 
@@ -75,11 +61,6 @@ class ConstraintGraphNode {
   /// various other nodes.
   ArrayRef<Constraint *> getConstraints() const { return Constraints; }
 
-  /// Retrieve the set of type variables to which this node is adjacent.
-  ArrayRef<TypeVariableType *> getAdjacencies() const {
-    return Adjacencies;
-  }
-
   /// Retrieve the set of type variables that are adjacent due to fixed
   /// bindings.
   ArrayRef<TypeVariableType *> getFixedBindings() const {
@@ -104,21 +85,6 @@ class ConstraintGraphNode {
   /// remove the corresponding adjacencies.
   void removeConstraint(Constraint *constraint);
 
-  /// Retrieve adjacency information for the given type variable.
-  Adjacency &getAdjacency(TypeVariableType *typeVar);
-
-  /// Modify the adjacency information for the given type variable
-  /// directly. If the adjacency becomes empty afterward, it will be
-  /// removed.
-  void modifyAdjacency(TypeVariableType *typeVar,
-                       llvm::function_ref<void(Adjacency &adj)> modify);
-
-  /// Add an adjacency to the list of adjacencies.
-  void addAdjacency(TypeVariableType *typeVar);
-
-  /// Remove an adjacency from the list of adjacencies.
-  void removeAdjacency(TypeVariableType *typeVar);
-
   /// Add the given type variables to this node's equivalence class.
   void addToEquivalenceClass(ArrayRef<TypeVariableType *> typeVars);
 
@@ -140,14 +106,6 @@ class ConstraintGraphNode {
   /// to the index within the vector of constraints.
   llvm::SmallDenseMap<Constraint *, unsigned, 2> ConstraintIndex;
 
-  /// The set of adjacent type variables, in a stable order.
-  SmallVector<TypeVariableType *, 2> Adjacencies;
-
-  /// A mapping from each of the type variables adjacent to this
-  /// type variable to the index of the adjacency information in
-  /// \c Adjacencies.
-  llvm::SmallDenseMap<TypeVariableType *, Adjacency, 2> AdjacencyInfo;
-
   /// The set of type variables that occur within the fixed binding of
   /// this type variable.
   SmallVector<TypeVariableType *, 2> FixedBindings;