[QoI] Fix inference of inout closure parameters in generic contexts

Convert subtype constraints with inout on one side and type variable
on the other into fixed binding. Constriants like `inout T0 subtype T1`
where (T0 must be materializable) are created when closures are part
of the generic function parameters e.g. `func foo<T>(_ t: T, (inout T) -> Void) {}`
so when such function gets called e.g.
```
  var x = 42
  foo(x) { $0 = 0 }
```
it's going to try and map closure parameters type (inout T0) - where
is opened generic parameter T - to argument type (T1), which can
be 'inout' but it's uncertain at this stage, but since closure
'declaration' `{ $0 = 0 }` is wrapped inside of a function call,
it has to 'map' parameters to arguments instead of converting them,
see `ConstraintSystem::matchFunctionTypes`.

Resolves: SR-3520, SR-1976, SR-3073, SR-3479.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -1448,6 +1448,40 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
       SWIFT_FALLTHROUGH;
 
     case ConstraintKind::Subtype:
+      // Subtype constraints are subject for edge contraction,
+      // which is inappropriate in this case, because it's going to
+      // erase/lose 'inout' modifier after merging equivalence classes
+      // (if inout containts type var, see ConstraintGraph::contractEdges()),
+      // since right-hand side type variable must not be materializable
+      // it can simply get left-hand side as a fixed binding, otherwise fail.
+      if (type1->is<InOutType>() &&
+          type1->getInOutObjectType()->isTypeVariableOrMember() && typeVar2) {
+        // Left-hand side type is not materializable, so we need to
+        // check if it's even appropriate to have such a constraint
+        // between these two types, or fail early otherwise if right-hand
+        // side must be materializable.
+        if (typeVar2->getImpl().mustBeMaterializable())
+          return SolutionKind::Error;
+
+        // Constriants like `inout T0 subtype T1` where (T0 must be
+        // materializable) are created when closures are part of the generic
+        // function parameters e.g. `func foo<T>(_ t: T, (inout T) -> Void) {}`
+        // so when such function gets called e.g.
+        // ```
+        //  var x = 42
+        //  foo(x) { $0 = 0 }
+        // ```
+        // it's going to try and map closure parameters type (inout T0), where
+        // T0 is opened generic parameter T, to argument type (T1), which can
+        // be 'inout' but it's uncertain at this stage, but since closure
+        // 'declaration' `{ $0 = 0 }` is wrapped inside of a function call,
+        // it has to 'map' parameters to arguments instead of converting them,
+        // see `ConstraintSystem::matchFunctionTypes`.
+        assignFixedType(typeVar2, type1);
+        return SolutionKind::Solved;
+      }
+      SWIFT_FALLTHROUGH;
+
     case ConstraintKind::ArgumentConversion:
     case ConstraintKind::OperatorArgumentTupleConversion:
     case ConstraintKind::OperatorArgumentConversion:

test/Constraints/closures.swift

@@ -399,3 +399,41 @@ let mismatchInClosureResultType : (String) -> ((Int) -> Void) = {
 // SR-3520: Generic function taking closure with inout parameter can result in a variety of compiler errors or EXC_BAD_ACCESS
 func sr3520_1<T>(_ g: (inout T) -> Int) {}
 sr3520_1 { $0 = 1 } // expected-error {{cannot convert value of type '()' to closure result type 'Int'}}
+
+func sr3520_2<T>(_ item: T, _ update: (inout T) -> Void) {
+  var x = item
+  update(&x)
+}
+var sr3250_arg = 42
+sr3520_2(sr3250_arg) { $0 += 3 } // ok
+
+// This test makes sure that having closure with inout argument doesn't crash with member lookup
+struct S_3520 {
+  var number1: Int
+}
+func sr3520_set_via_closure<S, T>(_ closure: (inout S, T) -> ()) {}
+sr3520_set_via_closure({ $0.number1 = $1 }) // expected-error {{type of expression is ambiguous without more context}}
+
+// SR-1976/SR-3073: Inference of inout
+func sr1976<T>(_ closure: (inout T) -> Void) {}
+sr1976({ $0 += 2 }) // ok
+
+// SR-3073: UnresolvedDotExpr in single expression closure
+
+struct SR3073Lense<Whole, Part> {
+  let set: (inout Whole, Part) -> ()
+}
+struct SR3073 {
+  var number1: Int
+  func lenses() {
+    let _: SR3073Lense<SR3073, Int> = SR3073Lense(
+      set: { $0.number1 = $1 } // ok
+    )
+  }
+}
+
+// SR-3479: Segmentation fault and other error for closure with inout parameter
+func sr3497_unfold<A, B>(_ a0: A, next: (inout A) -> B) {}
+func sr3497() {
+  let _ = sr3497_unfold((0, 0)) { s in 0 } // ok
+}