Merge pull request swiftlang#22526 from xedin/rdar-47967277

[CSBindings] Preserve l-valueness of optional object type

Author: xedin

lib/Sema/CSBindings.cpp

@@ -374,6 +374,14 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
          "not a representative");
   assert(!typeVar->getImpl().getFixedType(nullptr) && "has a fixed type");
 
+  // Determines whether this type variable represents an object
+  // of the optional type extracted by force unwrap.
+  bool isOptionalObject = false;
+  if (auto *locator = typeVar->getImpl().getLocator()) {
+    auto *anchor = locator->getAnchor();
+    isOptionalObject = anchor && isa<ForceValueExpr>(anchor);
+  }
+
   // Gather the constraints associated with this type variable.
   llvm::SetVector<Constraint *> constraints;
   getConstraintGraph().gatherConstraints(
@@ -425,6 +433,18 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
       if (exactTypes.insert(type->getCanonicalType()).second) {
         result.addPotentialBinding(*binding);
 
+        // Result of force unwrap is always connected to its base
+        // optional type via `OptionalObject` constraint which
+        // preserves l-valueness, so in case where object type got
+        // inferred before optional type (because it got the
+        // type from context e.g. parameter type of a function call),
+        // we need to test type with and without l-value after
+        // delaying bindings for as long as possible.
+        if (isOptionalObject && !type->is<LValueType>()) {
+          result.addPotentialBinding(binding->withType(LValueType::get(type)));
+          result.FullyBound = true;
+        }
+
         if (auto *locator = typeVar->getImpl().getLocator()) {
           auto path = locator->getPath();
           auto voidType = getASTContext().TheEmptyTupleType;

test/Constraints/optional.swift

@@ -302,3 +302,34 @@ func rdar45218255(_ i: Int) {
   _ = [i!]         // expected-error {{cannot force unwrap value of non-optional type 'Int'}} {{9-10=}}
   _ = S<Int>([i!]) // expected-error {{cannot force unwrap value of non-optional type 'Int'}} {{16-17=}}
 }
+
+// rdar://problem/47967277 - cannot assign through '!': '$0' is immutable
+func sr_9893_1() {
+  func foo<T : Equatable>(_: @autoclosure () throws -> T,
+                          _: @autoclosure () throws -> T) {}
+
+  class A {
+    var bar: String?
+  }
+
+  let r1 = A()
+  let r2 = A()
+
+  let arr1: [A] = []
+  foo(Set(arr1.map { $0.bar! }), Set([r1, r2].map { $0.bar! })) // Ok
+}
+
+func sr_9893_2(cString: UnsafePointer<CChar>) {
+  struct S {
+    var a: Int32 = 0
+    var b = ContiguousArray<CChar>(repeating: 0, count: 10)
+  }
+
+  var s = S()
+
+  withUnsafeMutablePointer(to: &s.a) { ptrA in
+    s.b.withUnsafeMutableBufferPointer { bufferB in
+      withVaList([ptrA, bufferB.baseAddress!]) { ptr in } // Ok
+    }
+  }
+}