[CSBindings] NFC: Adjust static member lookup feature to recent PotentialBindings changes

- `ConstraintSystem` is now referenced as a member of `PotentialBindings`;
- Literals and defaults are no longer added to the `Bindings` list, so we
  to add a new method `hasViableBindings` to make sure that protocol types
  are added only when there are no other bindings.

Author: xedin

include/swift/Sema/CSBindings.h

@@ -276,8 +276,20 @@ struct PotentialBindings {
 
   /// Determine whether the set of bindings is non-empty.
   explicit operator bool() const {
+    return hasViableBindings()|| isDirectHole();
+  }
+
+  /// Determine whether this set has any "viable" (or non-hole) bindings.
+  ///
+  /// A viable binding could be - a direct or transitive binding
+  /// inferred from a constraint, literal binding, or defaltable
+  /// binding.
+  ///
+  /// A hole is not considered a viable binding since it doesn't
+  /// add any new type information to constraint system.
+  bool hasViableBindings() const {
     return !Bindings.empty() || getNumViableLiteralBindings() > 0 ||
-           !Defaults.empty() || isDirectHole();
+           !Defaults.empty();
   }
 
   /// Determines whether this type variable could be `nil`,

lib/Sema/CSBindings.cpp

@@ -448,7 +448,7 @@ void PotentialBindings::finalize(
       // func foo<T: P>(_: T) {}
       // foo(.bar) <- `.bar` should be a static member of `P`.
       // \endcode
-      if (Bindings.empty() && TransitiveProtocols.hasValue()) {
+      if (!hasViableBindings() && TransitiveProtocols.hasValue()) {
         for (auto *constraint : *TransitiveProtocols) {
           auto protocolTy = constraint->getSecondType();
           addPotentialBinding(
@@ -457,29 +457,25 @@ void PotentialBindings::finalize(
       }
     }
 
-    if (cs.shouldAttemptFixes() &&
+    if (CS.shouldAttemptFixes() &&
         locator->isLastElement<LocatorPathElt::UnresolvedMemberChainResult>()) {
-      // Let's see whether this chain is valid, is it isn't then to avoid
+      // Let's see whether this chain is valid, if it isn't then to avoid
       // diagnosing the same issue multiple different ways, let's infer
       // result of the chain to be a hole.
       auto *resultExpr =
           castToExpr<UnresolvedMemberChainResultExpr>(locator->getAnchor());
-      auto *baseLocator = cs.getConstraintLocator(
+      auto *baseLocator = CS.getConstraintLocator(
           resultExpr->getChainBase(), ConstraintLocator::UnresolvedMember);
 
-      if (cs.hasFixFor(
+      if (CS.hasFixFor(
               baseLocator,
               FixKind::AllowInvalidStaticMemberRefOnProtocolMetatype)) {
-        cs.recordPotentialHole(TypeVar);
-        // Clear all of the previously inferred bindings which are inferred
+        CS.recordPotentialHole(TypeVar);
+        // Clear all of the previously collected bindings which are inferred
         // from inside of a member chain.
-        Bindings.erase(
-            llvm::remove_if(
-                Bindings,
-                [](const ConstraintSystem::PotentialBinding &binding) {
-                  return binding.Kind == AllowedBindingKind::Supertypes;
-                }),
-            Bindings.end());
+        Bindings.remove_if([](const PotentialBinding &binding) {
+          return binding.Kind == AllowedBindingKind::Supertypes;
+        });
       }
     }
   }