[CSBindings] Infer bindings through inout in some cases

Allow inferring type of `inout` from a pointer type
(or optional thereof) but delay the binding set because
it might not be complete and object type of `inout` could
also be an Array or C-style pointer type.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -1484,6 +1484,23 @@ PotentialBindings::inferFromRelational(Constraint *constraint) {
         AdjacentVars.insert({typeVar, constraint});
     }
 
+    // Infer a binding from `inout $T <convertible to> Unsafe*Pointer<...>?`.
+    if (first->is<InOutType>() &&
+        first->getInOutObjectType()->isEqual(TypeVar)) {
+      if (auto pointeeTy = second->lookThroughAllOptionalTypes()
+                               ->getAnyPointerElementType()) {
+        if (!pointeeTy->isTypeVariableOrMember()) {
+          // The binding is as a fallback in this case because $T could
+          // also be Array<X> or C-style pointer.
+          if (constraint->getKind() >= ConstraintKind::ArgumentConversion)
+            DelayedBy.push_back(constraint);
+
+          return PotentialBinding(pointeeTy, AllowedBindingKind::Exact,
+                                  constraint);
+        }
+      }
+    }
+
     return std::nullopt;
   }
 

test/Constraints/valid_pointer_conversions.swift

@@ -51,3 +51,21 @@ do {
 func rdar68254165(ptr: UnsafeMutablePointer<Int8>) {
   _ = String(decodingCString: ptr, as: .utf8) // expected-error {{generic parameter 'Encoding' could not be inferred}}
 }
+
+// The base of leading-dot syntax could be inferred through an implicit pointer conversion.
+do {
+  struct S {
+    static var prop = S()
+  }
+
+  func inference_through_optional(_ ptr: UnsafePointer<S>?) {}
+
+  inference_through_optional(&.prop) // Ok
+
+  func inference_through_force_unwrap(name: String) {
+    func test(_: UnsafeMutablePointer<Float>!) {}
+
+    var outputs = [String: [Float]]()
+    test(&outputs[name]!) // Ok
+  }
+}