[Diagnostics] Extend the AllowInOutConversion fix to cover inout attribute

mismatches in function types.

This improves the diagnostic in cases where we have argument-to-parameter
conversion failures or contextual type mismatches due to inout attribute
mismatches.

Author: hborla

lib/Sema/CSDiagnostics.cpp

@@ -4264,6 +4264,30 @@ bool ThrowingFunctionConversionFailure::diagnoseAsError() {
 
 bool InOutConversionFailure::diagnoseAsError() {
   auto *anchor = getAnchor();
+  auto *locator = getLocator();
+  auto path = locator->getPath();
+
+  if (!path.empty() &&
+      path.back().getKind() == ConstraintLocator::FunctionArgument) {
+    if (auto argApplyInfo = getFunctionArgApplyInfo(locator)) {
+      emitDiagnostic(anchor->getLoc(), diag::cannot_convert_argument_value,
+          argApplyInfo->getArgType(), argApplyInfo->getParamType());
+    } else {
+      assert(locator->findLast<LocatorPathElt::ContextualType>());
+      auto contextualType = getConstraintSystem().getContextualType();
+      auto purpose = getContextualTypePurpose();
+      auto diagnostic = getDiagnosticFor(purpose, /*forProtocol=*/false);
+
+      if (!diagnostic)
+        return false;
+
+      emitDiagnostic(anchor->getLoc(), *diagnostic, getType(anchor),
+                     contextualType);
+    }
+
+    return true;
+  }
+
   emitDiagnostic(anchor->getLoc(), diag::cannot_pass_rvalue_inout_converted,
                  getFromType(), getToType());
   fixItChangeArgumentType();

lib/Sema/CSFix.h

@@ -1289,7 +1289,7 @@ class IgnoreContextualType : public ContextualMismatch {
 };
 
 /// If this is an argument-to-parameter conversion which is associated with
-/// `inout` parameter, subtyping is now permitted, types have to
+/// `inout` parameter, subtyping is not permitted, types have to
 /// be identical.
 class AllowInOutConversion final : public ContextualMismatch {
   AllowInOutConversion(ConstraintSystem &cs, Type argType, Type paramType,

lib/Sema/CSSimplify.cpp

@@ -2603,6 +2603,24 @@ bool ConstraintSystem::repairFailures(
           *this, fnType, {FunctionType::Param(*arg)},
           getConstraintLocator(anchor, path)));
     }
+
+    if ((lhs->is<InOutType>() && !rhs->is<InOutType>()) ||
+        (!lhs->is<InOutType>() && rhs->is<InOutType>())) {
+      // We want to call matchTypes with the default decomposition options
+      // in case there are type variables that we couldn't bind due to the
+      // inout attribute mismatch.
+      auto result = matchTypes(lhs->getInOutObjectType(),
+                               rhs->getInOutObjectType(), matchKind,
+                               getDefaultDecompositionOptions(TMF_ApplyingFix),
+                               locator);
+
+      if (result.isSuccess()) {
+        conversionsOrFixes.push_back(AllowInOutConversion::create(*this, lhs,
+            rhs, getConstraintLocator(locator)));
+        break;
+      }
+    }
+
     break;
   }
 

test/Constraints/closures.swift

@@ -37,18 +37,18 @@ func inoutToSharedConversions() {
   fooOW({ (x : Int) in return Int(5) }) // defaut-to-'__owned' allowed
   fooOW({ (x : __owned Int) in return Int(5) }) // '__owned'-to-'__owned' allowed
   fooOW({ (x : __shared Int) in return Int(5) }) // '__shared'-to-'__owned' allowed
-  fooOW({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(__owned _) -> _'}}
+  fooOW({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(__owned Int) -> Int'}}
 
   func fooIO<T, U>(_ f : (inout T) -> U) {}
   fooIO({ (x : inout Int) in return Int(5) }) // 'inout'-to-'inout' allowed
-  fooIO({ (x : Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(inout _) -> _'}}
-  fooIO({ (x : __shared Int) in return Int(5) }) // expected-error {{cannot convert value of type '(__shared Int) -> Int' to expected argument type '(inout _) -> _'}}
-  fooIO({ (x : __owned Int) in return Int(5) }) // expected-error {{cannot convert value of type '(__owned Int) -> Int' to expected argument type '(inout _) -> _'}}
+  fooIO({ (x : Int) in return Int(5) }) // expected-error {{cannot convert value of type '(Int) -> Int' to expected argument type '(inout Int) -> Int'}}
+  fooIO({ (x : __shared Int) in return Int(5) }) // expected-error {{cannot convert value of type '(__shared Int) -> Int' to expected argument type '(inout Int) -> Int'}}
+  fooIO({ (x : __owned Int) in return Int(5) }) // expected-error {{cannot convert value of type '(__owned Int) -> Int' to expected argument type '(inout Int) -> Int'}}
 
   func fooSH<T, U>(_ f : (__shared T) -> U) {}
   fooSH({ (x : __shared Int) in return Int(5) }) // '__shared'-to-'__shared' allowed
   fooSH({ (x : __owned Int) in return Int(5) }) // '__owned'-to-'__shared' allowed
-  fooSH({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(__shared _) -> _'}}
+  fooSH({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(__shared Int) -> Int'}}
   fooSH({ (x : Int) in return Int(5) }) // default-to-'__shared' allowed
 }
 
@@ -862,8 +862,8 @@ func rdar45771997() {
 struct rdar30347997 {
   func withUnsafeMutableBufferPointer(body : (inout Int) -> ()) {}
   func foo() {
-    withUnsafeMutableBufferPointer {
-      (b : Int) in // expected-error {{'Int' is not convertible to 'inout Int'}}
+    withUnsafeMutableBufferPointer { // expected-error {{cannot convert value of type '(Int) -> ()' to expected argument type '(inout Int) -> ()'}}
+      (b : Int) in
     }
   }
 }

test/Generics/materializable_restrictions.swift

@@ -15,10 +15,10 @@ func test20807269() {
 func test15921530() {
     struct X {}
 
-    func makef<T>() -> (T) -> () { // expected-note {{in call to function 'makef()'}}
+    func makef<T>() -> (T) -> () {
       return {
         x in ()
       }
     }
-    var _: (inout X) -> () = makef() // expected-error{{generic parameter 'T' could not be inferred}}
+    var _: (inout X) -> () = makef() // expected-error{{cannot convert value of type '(X) -> ()' to specified type '(inout X) -> ()'}}
 }