[CSBindings] Infer key path root bindings transitively through contextual root variable

Since generic arguments have to match exactly the inference could
be extended to transfer bindings through contextual root types if
they are sufficiently resolved (not delayed).

For example if key path expression is passed as an argument to
a parameter like `WritableKeyPath<$Root, $Value>` and `$Root`
is not yet bound but has a binding set of `{String}` its bindings
are transferable over to resolve the key path which would be
ultimately bound to the contextual type.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -457,9 +457,28 @@ void BindingSet::inferTransitiveBindings(
               inferredRootTy = fnType->getParams()[0].getParameterType();
           }
 
-          if (inferredRootTy && !inferredRootTy->isTypeVariableOrMember())
-            addBinding(
+          if (inferredRootTy) {
+            // If contextual root is not yet resolved, let's try to see if
+            // there are any bindings in its set. The bindings could be
+            // transitively used because conversions between generic arguments
+            // are not allowed.
+            if (auto *contextualRootVar = inferredRootTy->getAs<TypeVariableType>()) {
+              auto rootBindings = inferredBindings.find(contextualRootVar);
+              if (rootBindings != inferredBindings.end()) {
+                auto &bindings = rootBindings->getSecond();
+
+                // Don't infer if root is not yet fully resolved.
+                if (bindings.isDelayed())
+                  continue;
+
+                for (const auto &binding : bindings.Bindings)
+                  addBinding(binding);
+              }
+            } else {
+              addBinding(
                 binding.withSameSource(inferredRootTy, BindingKind::Exact));
+            }
+          }
         }
       }
     }

test/Sema/keypath_bidirectional_inference.swift

@@ -0,0 +1,64 @@
+// RUN: %target-typecheck-verify-swift -target %target-cpu-apple-macosx10.15 -solver-expression-time-threshold=1 -swift-version 5
+
+// REQUIRES: OS=macosx
+
+import Combine
+
+enum Status {
+  case up
+  case down
+}
+
+protocol StatusMonitor {
+  var statusPublisher: AnyPublisher<Status, Never> { get }
+}
+
+protocol UIController {}
+protocol ControllerProtocol {}
+
+class TestViewController : UIController, ControllerProtocol {
+}
+
+class OtherController {
+  var innerController: (any UIController & ControllerProtocol)? = nil
+}
+
+class Test1 {
+  var monitor: StatusMonitor
+
+  var subscriptions: [AnyCancellable] = []
+  var status: Status? = nil
+  var statuses: [Status]? = nil
+
+  init(monitor: StatusMonitor) {
+    self.monitor = monitor
+  }
+
+  func simpleMapTest() {
+    monitor.statusPublisher
+           .map { $0 }
+           .assign(to: \.status, on: self) // Ok
+           .store(in: &subscriptions)
+  }
+
+  func transformationTest() {
+    monitor.statusPublisher
+           .map { _ in (0...1).map { _ in .up } }
+           .assign(to: \.statuses, on: self) // Ok
+           .store(in: &subscriptions)
+  }
+}
+
+class FilteringTest {
+  @Published var flag = false
+
+  func test(viewController: inout OtherController) {
+    _ = $flag.filter { !$0 }
+             .map { _ in TestViewController() }
+             .first()
+             .handleEvents(receiveOutput: { _ in
+               print("event")
+             })
+             .assign(to: \.innerController, on: viewController) // Ok
+  }
+}