[ConstraintGraph] Extract logic related to fixed types into dedicated methods on graph node

Author: xedin

include/swift/Sema/ConstraintGraph.h

@@ -135,6 +135,24 @@ class ConstraintGraphNode {
   /// equivalence class changes.
   void reintroduceToInference(Constraint *constraint, bool notifyReferencedVars);
 
+  /// Similar to \c introduceToInference(Constraint *, ...) this method is going
+  /// to notify inference that this type variable has been bound to a concrete
+  /// type.
+  ///
+  /// The reason why this can't simplify be a part of \c bindTypeVariable
+  /// is related to the fact that it's sometimes expensive to re-compute
+  /// bindings (i.e. if `DependentMemberType` is involved, because it requires
+  /// a conformance lookup), so inference has to be delayed until its clear that
+  /// type variable has been bound to a valid type and solver can make progress.
+  void
+  introduceToInference(Type fixedType,
+                       SmallPtrSetImpl<TypeVariableType *> &referencedVars);
+
+  /// Opposite of \c introduceToInference(Type, ...)
+  void
+  retractFromInference(Type fixedType,
+                       SmallPtrSetImpl<TypeVariableType *> &referencedVars);
+
   /// Drop all previously collected bindings and re-infer based on the
   /// current set constraints associated with this equivalence class.
   void resetBindingSet();
@@ -148,6 +166,7 @@ class ConstraintGraphNode {
   /// This is useful in situations when type variable gets bound and unbound,
   /// or equivalence class changes.
   void notifyReferencingVars() const;
+
   /// }
 
   /// The constraint graph this node belongs to.

lib/Sema/ConstraintGraph.cpp

@@ -335,6 +335,46 @@ void ConstraintGraphNode::reintroduceToInference(Constraint *constraint,
   introduceToInference(constraint, notifyReferencedVars);
 }
 
+void ConstraintGraphNode::introduceToInference(
+    Type fixedType, SmallPtrSetImpl<TypeVariableType *> &referencedVars) {
+  // Notify all of the type variables that reference this one.
+  //
+  // Since this type variable has been replaced with a fixed type
+  // all of the concrete types that reference it are going to change,
+  // which means that all of the not-yet-attempted bindings should
+  // change as well.
+  notifyReferencingVars();
+
+  for (auto *referencedVar : referencedVars) {
+    auto &node = CG[referencedVar];
+
+    // Newly referred vars need to re-introduce all constraints associated
+    // with this type variable since they are now going to be used in
+    // all of the constraints that reference bound type variable.
+    for (auto *constraint : getConstraints()) {
+      if (isUsefulForReferencedVars(constraint))
+        node.reintroduceToInference(constraint,
+                                    /*notifyReferencedVars=*/false);
+    }
+  }
+}
+
+void ConstraintGraphNode::retractFromInference(
+    Type fixedType, SmallPtrSetImpl<TypeVariableType *> &referencedVars) {
+  // Notify referencing variables (just like in bound case) that this
+  // type variable has been modified.
+  notifyReferencingVars();
+
+  // TODO: This might be an overkill but it's (currently)
+  // the simpliest way to reliably ensure that all of the
+  // no longer related constraints have been retracted.
+  for (auto *referencedVar : referencedVars) {
+    auto &node = CG[referencedVar];
+    if (node.forRepresentativeVar())
+      node.resetBindingSet();
+  }
+}
+
 void ConstraintGraphNode::resetBindingSet() {
   assert(forRepresentativeVar());
 
@@ -541,65 +581,36 @@ void ConstraintGraph::bindTypeVariable(TypeVariableType *typeVar, Type fixed) {
 
   auto &node = (*this)[typeVar];
 
-  // Notify all of the type variables that reference this one.
-  //
-  // Since this type variable has been replaced with a fixed type
-  // all of the concrete types that reference it are going to change,
-  // which means that all of the not-yet-attempted bindings should
-  // change as well.
-  node.notifyReferencingVars();
-
-  if (!fixed->hasTypeVariable())
-    return;
-
-  llvm::SmallPtrSet<TypeVariableType *, 4> typeVars;
-  fixed->getTypeVariables(typeVars);
+  llvm::SmallPtrSet<TypeVariableType *, 4> referencedVars;
+  fixed->getTypeVariables(referencedVars);
 
-  for (auto otherTypeVar : typeVars) {
+  for (auto otherTypeVar : referencedVars) {
     if (typeVar == otherTypeVar)
       continue;
 
     auto &otherNode = (*this)[otherTypeVar];
 
     otherNode.addReferencedBy(typeVar);
     node.addReferencedVar(otherTypeVar);
-
-    // Newly referred vars need to re-introduce all constraints associated
-    // with this type variable since they are now going to be used in
-    // all of the constraints that reference bound type variable.
-    for (auto *constraint : (*this)[typeVar].getConstraints()) {
-      if (isUsefulForReferencedVars(constraint))
-        otherNode.reintroduceToInference(constraint,
-                                         /*notifyReferencedVars=*/false);
-    }
   }
+
+  node.introduceToInference(fixed, referencedVars);
 }
 
 void ConstraintGraph::unbindTypeVariable(TypeVariableType *typeVar, Type fixed) {
   auto &node = (*this)[typeVar];
 
-  // Notify referencing variables (just like in bound case) that this
-  // type variable has been modified.
-  node.notifyReferencingVars();
+  llvm::SmallPtrSet<TypeVariableType *, 4> referencedVars;
+  fixed->getTypeVariables(referencedVars);
 
-  if (!fixed->hasTypeVariable())
-    return;
-
-  llvm::SmallPtrSet<TypeVariableType *, 4> typeVars;
-  fixed->getTypeVariables(typeVars);
-
-  for (auto otherTypeVar : typeVars) {
+  for (auto otherTypeVar : referencedVars) {
     auto &otherNode = (*this)[otherTypeVar];
 
     otherNode.removeReferencedBy(typeVar);
     node.removeReference(otherTypeVar);
-
-    // TODO: This might be an overkill but it's (currently)
-    // the simpliest way to reliably ensure that all of the
-    // no longer related constraints have been retracted.
-    if (otherNode.forRepresentativeVar())
-      otherNode.resetBindingSet();
   }
+
+  node.retractFromInference(fixed, referencedVars);
 }
 
 #pragma mark Algorithms