[Diagnostics] Improve the diagnostic for invalid optional pointer conversions for an

autoclosure result type.

Skip `ConstraintLocator::OptionalPayload` when checking if we're in an autoclosure context for
an inout-to-pointer conversion. This lets us apply the `AllowAutoClosurePointerConversion`
constraint fix when the pointer is optional.

This resolves rdar://problem/53532404

Author: hborla

lib/Sema/CSSimplify.cpp

@@ -3080,10 +3080,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
   if (kind >= ConstraintKind::Conversion) {
     // It is never legal to form an autoclosure that results in these
     // implicit conversions to pointer types.
-    bool isAutoClosureArgument = false;
-    if (auto last = locator.last())
-      if (last->getKind() == ConstraintLocator::AutoclosureResult)
-        isAutoClosureArgument = true;
+    bool isAutoClosureArgument = locator.isAutoclosureResult();
 
     // Pointer arguments can be converted from pointer-compatible types.
     if (kind >= ConstraintKind::ArgumentConversion) {

lib/Sema/ConstraintLocator.h

@@ -715,6 +715,21 @@ class ConstraintLocatorBuilder {
     return (getSummaryFlags() & ConstraintLocator::IsFunctionConversion);
   }
 
+  bool isAutoclosureResult() const {
+    SmallVector<LocatorPathElt, 4> path;
+    getLocatorParts(path);
+
+    auto last = std::find_if(
+        path.rbegin(), path.rend(), [](LocatorPathElt &elt) -> bool {
+          return elt.getKind() != ConstraintLocator::OptionalPayload;
+        });
+
+    if (last != path.rend())
+      return last->getKind() == ConstraintLocator::AutoclosureResult;
+
+    return false;
+  }
+
   /// Retrieve the base constraint locator, on which this builder's
   /// path is based.
   ConstraintLocator *getBaseLocator() const {

test/Constraints/invalid_implicit_conversions.swift

@@ -9,7 +9,8 @@ func test(
   _ ptr: UnsafePointer<Int>,
   _ ptrI8: UnsafePointer<Int8>,
   _ ptrU8: UnsafePointer<UInt8>,
-  _ ptrVoid: UnsafePointer<Void> // expected-warning {{UnsafePointer<Void> has been replaced by UnsafeRawPointer}}
+  _ ptrVoid: UnsafePointer<Void>, // expected-warning {{UnsafePointer<Void> has been replaced by UnsafeRawPointer}}
+  _ optPtr: UnsafePointer<Int>?
 ) {
   var i: Int = 0
   var a: [Int] = [0]
@@ -23,6 +24,7 @@ func test(
   takesAutoclosure(mutRawPtr, &a) // expected-error {{cannot perform pointer conversion of value of type '[Int]' to autoclosure result type 'UnsafeMutableRawPointer'}}
   takesAutoclosure(mutPtr, &a) // expected-error {{cannot perform pointer conversion of value of type '[Int]' to autoclosure result type 'UnsafeMutablePointer<Int>'}}
   takesAutoclosure(ptr, &a) // expected-error {{cannot perform pointer conversion of value of type '[Int]' to autoclosure result type 'UnsafePointer<Int>'}}
+  takesAutoclosure(optPtr, &i) // expected-error {{cannot perform pointer conversion of value of type 'Int' to autoclosure result type 'UnsafePointer<Int>?'}}
 
   takesAutoclosure(rawPtr, a) // expected-error {{cannot invoke 'takesAutoclosure' with an argument list of type '(UnsafeRawPointer, [Int])'}}
   // expected-note@-1 {{expected an argument list of type '(T, @autoclosure () throws -> T)'}}