[ConstraintSystem] Determine whether type variable is a hole on demand

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -4730,9 +4730,6 @@ class ConstraintSystem {
     /// Whether the bindings of this type involve other type variables.
     bool InvolvesTypeVariables = false;
 
-    /// Whether this type variable is considered a hole in the constraint system.
-    bool IsHole = false;
-
     /// Whether the bindings represent (potentially) incomplete set,
     /// there is no way to say with absolute certainty if that's the
     /// case, but that could happen when certain constraints like
@@ -4761,6 +4758,17 @@ class ConstraintSystem {
     /// Determine whether the set of bindings is non-empty.
     explicit operator bool() const { return !Bindings.empty(); }
 
+    /// If there is only one binding and it's to a hole type, consider
+    /// this type variable to be a hole in a constraint system regardless
+    /// of where hole type originated.
+    bool isHole() const {
+      if (Bindings.size() != 1)
+        return false;
+
+      auto &binding = Bindings.front();
+      return binding.BindingType->is<HoleType>();
+    }
+
     /// Determine if the bindings only constrain the type variable from above
     /// with an existential type; such a binding is not very helpful because
     /// it's impossible to enumerate the existential type's subtypes.
@@ -4784,7 +4792,7 @@ class ConstraintSystem {
       auto numDefaults = b.getNumDefaultableBindings();
       auto hasNoDefaultableBindings = b.Bindings.size() > numDefaults;
 
-      return std::make_tuple(b.IsHole,
+      return std::make_tuple(b.isHole(),
                              !hasNoDefaultableBindings,
                              b.FullyBound,
                              b.isSubtypeOfExistentialType(),
@@ -4820,7 +4828,7 @@ class ConstraintSystem {
       // for "subtype" type variable to attempt more bindings later.
       // This is required because algorithm can't currently infer
       // bindings for subtype transitively through superclass ones.
-      if (!(x.IsHole && y.IsHole)) {
+      if (!(std::get<0>(xScore) && std::get<0>(yScore))) {
         if (x.isSubtypeOf(y.TypeVar))
           return false;
 

lib/Sema/CSBindings.cpp

@@ -462,7 +462,6 @@ void ConstraintSystem::PotentialBindings::finalize(
   // If there are no bindings, typeVar may be a hole.
   if (cs.shouldAttemptFixes() && Bindings.empty() &&
       TypeVar->getImpl().canBindToHole()) {
-    IsHole = true;
     // If the base of the unresolved member reference like `.foo`
     // couldn't be resolved we'd want to bind it to a hole at the
     // very last moment possible, just like generic parameters.
@@ -695,7 +694,7 @@ bool ConstraintSystem::PotentialBindings::isViable(
 
 bool ConstraintSystem::PotentialBindings::favoredOverDisjunction(
     Constraint *disjunction) const {
-  if (IsHole || FullyBound)
+  if (isHole() || FullyBound)
     return false;
 
   // If this bindings are for a closure and there are no holes,

lib/Sema/ConstraintGraph.cpp

@@ -1113,7 +1113,7 @@ bool ConstraintGraph::contractEdges() {
       bool isNotContractable = true;
       if (auto bindings = CS.inferBindingsFor(tyvar1)) {
         // Holes can't be contracted.
-        if (bindings.IsHole)
+        if (bindings.isHole())
           continue;
 
         for (auto &binding : bindings.Bindings) {