[Diagnostics] Move fix creation of AllowAutoClosurePointerConversion from

`matchTypes` to `repairFailures`.

This change handles invalid inout-to-pointer, array-to-pointer, and string-
to-pointer autoclosure conversions in the same way.

Author: hborla

lib/Sema/CSFix.h

@@ -98,10 +98,6 @@ enum class FixKind : uint8_t {
   /// Swift version 5.
   AutoClosureForwarding,
 
-  /// Allow invalid pointer conversions for autoclosure result types as if the
-  /// pointer type is a function parameter rather than an autoclosure result.
-  AllowAutoClosurePointerConversion,
-
   /// Remove `!` or `?` because base is not an optional type.
   RemoveUnwrap,
 
@@ -627,11 +623,12 @@ class AutoClosureForwarding final : public ConstraintFix {
                                        ConstraintLocator *locator);
 };
 
+/// Allow invalid pointer conversions for autoclosure result types as if the
+/// pointer type is a function parameter rather than an autoclosure result.
 class AllowAutoClosurePointerConversion final : public ContextualMismatch {
   AllowAutoClosurePointerConversion(ConstraintSystem &cs, Type pointeeType,
                                     Type pointerType, ConstraintLocator *locator)
-      : ContextualMismatch(cs, FixKind::AllowAutoClosurePointerConversion,
-                           pointeeType, pointerType, locator) {}
+      : ContextualMismatch(cs, pointeeType, pointerType, locator) {}
 
 public:
   std::string getName() const override {

lib/Sema/CSSimplify.cpp

@@ -2488,6 +2488,14 @@ bool ConstraintSystem::repairFailures(
   case ConstraintLocator::AutoclosureResult: {
     if (repairByInsertingExplicitCall(lhs, rhs))
       return true;
+
+    auto result = matchTypes(lhs, rhs, ConstraintKind::ArgumentConversion,
+        TypeMatchFlags::TMF_ApplyingFix,
+        locator.withPathElement(ConstraintLocator::FunctionArgument));
+
+    if (result.isSuccess())
+      conversionsOrFixes.push_back(AllowAutoClosurePointerConversion::create(
+          *this, lhs, rhs, getConstraintLocator(locator)));
     break;
   }
 
@@ -3116,11 +3124,6 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
               }
               conversionsOrFixes.push_back(
                   ConversionRestrictionKind::InoutToPointer);
-            } else {
-              Type pointeeType = inoutType1->getObjectType();
-              auto *fix = AllowAutoClosurePointerConversion::create(*this,
-                  pointeeType, type2, getConstraintLocator(locator));
-              conversionsOrFixes.push_back(fix);
             }
           }
 
@@ -7010,13 +7013,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
     return matchTupleTypes(matchingType, smaller, matchKind, subflags, locator);
   }
 
-  case FixKind::AllowAutoClosurePointerConversion: {
-    if (recordFix(fix))
-      return SolutionKind::Error;
-    return matchTypes(type1, type2, matchKind, subflags,
-        locator.withPathElement(ConstraintLocator::FunctionArgument));
-  }
-
   case FixKind::InsertCall:
   case FixKind::RemoveReturn:
   case FixKind::AddConformance:

lib/Sema/ConstraintLocator.h

@@ -721,7 +721,8 @@ class ConstraintLocatorBuilder {
 
     auto last = std::find_if(
         path.rbegin(), path.rend(), [](LocatorPathElt &elt) -> bool {
-          return elt.getKind() != ConstraintLocator::OptionalPayload;
+          return elt.getKind() != ConstraintLocator::OptionalPayload &&
+                 elt.getKind() != ConstraintLocator::GenericArgument;
         });
 
     if (last != path.rend())

test/Constraints/invalid_implicit_conversions.swift

@@ -14,6 +14,7 @@ func test(
 ) {
   var i: Int = 0
   var a: [Int] = [0]
+  var b: [Int]? = [0]
   let s = "string"
 
   takesAutoclosure(rawPtr, &i) // expected-error {{cannot perform pointer conversion of value of type 'Int' to autoclosure result type 'UnsafeRawPointer'}}
@@ -26,17 +27,12 @@ func test(
   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)'}}
-  takesAutoclosure(ptr, a) // expected-error {{cannot invoke 'takesAutoclosure' with an argument list of type '(UnsafePointer<Int>, [Int])'}}
-  // expected-note@-1 {{expected an argument list of type '(T, @autoclosure () throws -> T)'}}
+  takesAutoclosure(rawPtr, a) // expected-error {{cannot perform pointer conversion of value of type '[Int]' to autoclosure result type 'UnsafeRawPointer'}}
+  takesAutoclosure(ptr, a) // expected-error {{cannot perform pointer conversion of value of type '[Int]' to autoclosure result type 'UnsafePointer<Int>'}}
+  takesAutoclosure(optPtr, b) // expected-error {{cannot perform pointer conversion of value of type '[Int]?' to autoclosure result type 'UnsafePointer<Int>?'}}
 
-  takesAutoclosure(rawPtr, s) // expected-error {{cannot invoke 'takesAutoclosure' with an argument list of type '(UnsafeRawPointer, String)'}}
-  // expected-note@-1 {{expected an argument list of type '(T, @autoclosure () throws -> T)'}}
-  takesAutoclosure(ptrI8, s) // expected-error {{cannot invoke 'takesAutoclosure' with an argument list of type '(UnsafePointer<Int8>, String)'}}
-  // expected-note@-1 {{expected an argument list of type '(T, @autoclosure () throws -> T)'}}
-  takesAutoclosure(ptrU8, s) // expected-error {{cannot invoke 'takesAutoclosure' with an argument list of type '(UnsafePointer<UInt8>, String)'}}
-  // expected-note@-1 {{expected an argument list of type '(T, @autoclosure () throws -> T)'}}
-  takesAutoclosure(ptrVoid, s) // expected-error {{cannot invoke 'takesAutoclosure' with an argument list of type '(UnsafePointer<Void>, String)'}}
-  // expected-note@-1 {{expected an argument list of type '(T, @autoclosure () throws -> T)'}}
+  takesAutoclosure(rawPtr, s) // expected-error {{cannot perform pointer conversion of value of type 'String' to autoclosure result type 'UnsafeRawPointer'}}
+  takesAutoclosure(ptrI8, s) // expected-error {{cannot perform pointer conversion of value of type 'String' to autoclosure result type 'UnsafePointer<Int8>'}}
+  takesAutoclosure(ptrU8, s) // expected-error {{cannot perform pointer conversion of value of type 'String' to autoclosure result type 'UnsafePointer<UInt8>'}}
+  takesAutoclosure(ptrVoid, s) // expected-error {{cannot perform pointer conversion of value of type 'String' to autoclosure result type 'UnsafePointer<Void>'}}
 }