[CSBindings] Avoid delaying leading-dot inference only if chain is directly connected to a contextual type

Additional restrictions on when protocol inference could be considered
viable. If the chain is connected directly to a contextual type there
cannot be any other inference sources for the base type.

Resolves: rdar://148256978

Author: xedin

lib/Sema/CSBindings.cpp

@@ -130,12 +130,19 @@ bool BindingSet::isDelayed() const {
         return true;
 
       if (Bindings[0].BindingType->is<ProtocolType>()) {
-        auto *locator = Bindings[0].getLocator();
-        // If the binding got inferred from a contextual type
-        // this set shouldn't be delayed because there won't
-        // be any other inference sources for this leading-dot
-        // syntax member.
-        if (!locator->findLast<LocatorPathElt::ContextualType>())
+        auto *bindingLoc = Bindings[0].getLocator();
+        // This set shouldn't be delayed because there won't be any
+        // other inference sources when the protocol binding got
+        // inferred from a contextual type and the leading-dot chain
+        // this type variable is a base of, is connected directly to it.
+
+        if (!bindingLoc->findLast<LocatorPathElt::ContextualType>())
+          return true;
+
+        auto *chainResult =
+            getAsExpr<UnresolvedMemberChainResultExpr>(bindingLoc->getAnchor());
+        if (!chainResult || CS.getParentExpr(chainResult) ||
+            chainResult->getChainBase() != getAsExpr(locator->getAnchor()))
           return true;
       }
     }

test/expr/delayed-ident/member_chains.swift

@@ -382,3 +382,30 @@ func acceptInt(_ x: Int) {}
 func postfixOpIsNotAMemberChain() {
   acceptInt(.implicit.another^)
 }
+
+// Ensure that base type doesn't get bound to a protocol type too eagerly
+do {
+  struct V : Hashable {
+    static let v1: V = V()
+    static let v2: V = V()
+  }
+
+  let _: Set = [V.v1, .v2] // Ok
+
+  struct Elements : RandomAccessCollection {
+    init() {}
+    init(_ elements: [Int]) {}
+
+    var startIndex: Int { 0 }
+    var endIndex: Int { 0 }
+    subscript(index: Int) -> Int { 0 }
+  }
+
+  struct TestNilCoalescing {
+    var data: Elements?
+
+    func test() {
+      for _ in self.data ?? .init() {} // Ok
+    }
+  }
+}