[ConstraintSystem] Delay inference until let's clear that type variable attempt is successful

Currently bindings where inferred on every `bindTypeVariable` call,
but that's wasteful because not all binds are always correct. To
avoid unnecessary inference traffic let's wait until re-activated
constraints are simplified and notify binding inference about new
fixed type only if all of them are successful.

Author: xedin

include/swift/Sema/ConstraintGraph.h

@@ -44,6 +44,7 @@ class Constraint;
 class ConstraintGraph;
 class ConstraintGraphScope;
 class ConstraintSystem;
+class TypeVariableBinding;
 
 /// A single node in the constraint graph, which represents a type variable.
 class ConstraintGraphNode {
@@ -144,11 +145,9 @@ class ConstraintGraphNode {
   /// 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);
+  void introduceToInference(Type fixedType);
 
-  /// Opposite of \c introduceToInference(Type, ...)
+  /// Opposite of \c introduceToInference(Type)
   void
   retractFromInference(Type fixedType,
                        SmallPtrSetImpl<TypeVariableType *> &referencedVars);
@@ -211,6 +210,8 @@ class ConstraintGraphNode {
   void verify(ConstraintGraph &cg);
 
   friend class ConstraintGraph;
+  friend class ConstraintSystem;
+  friend class TypeVariableBinding;
 };
 
 /// A graph that describes the relationships among the various type variables

include/swift/Sema/ConstraintSystem.h

@@ -3631,6 +3631,10 @@ class ConstraintSystem {
 
     /// Indicates that we are applying a fix.
     TMF_ApplyingFix = 0x02,
+
+    /// Indicates that we are attempting a possible type for
+    /// a type variable.
+    TMF_BindingTypeVariable = 0x04,
   };
 
   /// Options that govern how type matching should proceed.
@@ -3702,10 +3706,14 @@ class ConstraintSystem {
   /// \param type The fixed type to which the type variable will be bound.
   ///
   /// \param updateState Whether to update the state based on this binding.
-  /// False when we're only assigning a type as part of reconstructing 
+  /// False when we're only assigning a type as part of reconstructing
   /// a complete solution from partial solutions.
+  ///
+  /// \param notifyBindingInference Whether to notify binding inference about
+  /// the change to this type variable.
   void assignFixedType(TypeVariableType *typeVar, Type type,
-                       bool updateState = true);
+                       bool updateState = true,
+                       bool notifyBindingInference = true);
 
   /// Determine if the type in question is an Array<T> and, if so, provide the
   /// element type of the array.

lib/Sema/CSBindings.cpp

@@ -1796,6 +1796,7 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
   ConstraintSystem::TypeMatchOptions options;
 
   options |= ConstraintSystem::TMF_GenerateConstraints;
+  options |= ConstraintSystem::TMF_BindingTypeVariable;
 
   auto result =
       cs.matchTypes(TypeVar, type, ConstraintKind::Bind, options, srcLocator);
@@ -1833,5 +1834,16 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
       return true;
   }
 
-  return !cs.simplify();
+  if (cs.simplify())
+    return false;
+
+  // If all of the re-activated constraints where simplified,
+  // let's notify binding inference about the fact that type
+  // variable has been bound successfully.
+  {
+    auto &CG = cs.getConstraintGraph();
+    CG[TypeVar].introduceToInference(type);
+  }
+
+  return true;
 }

lib/Sema/CSSimplify.cpp

@@ -3016,7 +3016,8 @@ ConstraintSystem::matchTypesBindTypeVar(
                : getTypeMatchFailure(locator);
   }
 
-  assignFixedType(typeVar, type);
+  assignFixedType(typeVar, type, /*updateState=*/true,
+                  /*notifyInference=*/!flags.contains(TMF_BindingTypeVariable));
 
   return getTypeMatchSuccess();
 }

lib/Sema/ConstraintGraph.cpp

@@ -335,8 +335,7 @@ void ConstraintGraphNode::reintroduceToInference(Constraint *constraint,
   introduceToInference(constraint, notifyReferencedVars);
 }
 
-void ConstraintGraphNode::introduceToInference(
-    Type fixedType, SmallPtrSetImpl<TypeVariableType *> &referencedVars) {
+void ConstraintGraphNode::introduceToInference(Type fixedType) {
   // Notify all of the type variables that reference this one.
   //
   // Since this type variable has been replaced with a fixed type
@@ -345,6 +344,12 @@ void ConstraintGraphNode::introduceToInference(
   // change as well.
   notifyReferencingVars();
 
+  if (!fixedType->hasTypeVariable())
+    return;
+
+  SmallPtrSet<TypeVariableType *, 4> referencedVars;
+  fixedType->getTypeVariables(referencedVars);
+
   for (auto *referencedVar : referencedVars) {
     auto &node = CG[referencedVar];
 
@@ -593,8 +598,6 @@ void ConstraintGraph::bindTypeVariable(TypeVariableType *typeVar, Type fixed) {
     otherNode.addReferencedBy(typeVar);
     node.addReferencedVar(otherTypeVar);
   }
-
-  node.introduceToInference(fixed, referencedVars);
 }
 
 void ConstraintGraph::unbindTypeVariable(TypeVariableType *typeVar, Type fixed) {

lib/Sema/ConstraintSystem.cpp

@@ -155,7 +155,8 @@ bool ConstraintSystem::typeVarOccursInType(TypeVariableType *typeVar,
 }
 
 void ConstraintSystem::assignFixedType(TypeVariableType *typeVar, Type type,
-                                       bool updateState) {
+                                       bool updateState,
+                                       bool notifyBindingInference) {
   assert(!type->hasError() &&
          "Should not be assigning a type involving ErrorType!");
 
@@ -199,6 +200,9 @@ void ConstraintSystem::assignFixedType(TypeVariableType *typeVar, Type type,
   // Notify the constraint graph.
   CG.bindTypeVariable(typeVar, type);
   addTypeVariableConstraintsToWorkList(typeVar);
+
+  if (notifyBindingInference)
+    CG[typeVar].introduceToInference(type);
 }
 
 void ConstraintSystem::addTypeVariableConstraintsToWorkList(