[Sema] Adjust escapeness function parameter diagnostic to use decl description

Author: LucianoPAlmeida

include/swift/AST/DiagnosticsSema.def

@@ -3892,8 +3892,8 @@ ERROR(converting_noattrfunc_to_type,none,
       (unsigned, Type))
 ERROR(converting_noattrfunc_contravariant_parameter_position,none,
       "converting escaping to non-escaping functions of type %2 in parameter position "
-      "#%0 of function type member %1 is not allowed",
-      (unsigned, Identifier, Type))
+      "#%0 of function type %3 %1 is not allowed",
+      (unsigned, Identifier, Type, DescriptiveDeclKind))
 NOTE(add_explicit_escaping,none,
      "add explicit @escaping to function parameter #%0",
      (unsigned))

lib/Sema/CSDiagnostics.cpp

@@ -905,6 +905,24 @@ bool AttributedFuncToTypeConversionFailure::diagnoseAsError() {
   return true;
 }
 
+static VarDecl *getDestinationVarDecl(AssignExpr *AE,
+                                      const Solution &solution) {
+  ConstraintLocator *locator = nullptr;
+  if (auto *URDE = dyn_cast<UnresolvedDotExpr>(AE->getDest())) {
+    locator = solution.getConstraintLocator(URDE, {ConstraintLocator::Member});
+  } else if (auto *declRef = dyn_cast<DeclRefExpr>(AE->getDest())) {
+    locator = solution.getConstraintLocator(declRef);
+  }
+  if (!locator)
+    return nullptr;
+
+  auto overload = solution.getOverloadChoiceIfAvailable(locator);
+  if (!overload)
+    return nullptr;
+
+  return dyn_cast_or_null<VarDecl>(overload->choice.getDecl());
+}
+
 bool AttributedFuncToTypeConversionFailure::
     diagnoseFunctionParameterEscapenessMismatch(AssignExpr *AE) const {
   auto loc = getLocator();
@@ -914,17 +932,8 @@ bool AttributedFuncToTypeConversionFailure::
   if (!loc->findLast<LocatorPathElt::FunctionArgument>())
     return false;
 
-  auto *URDE = dyn_cast<UnresolvedDotExpr>(AE->getDest());
-  if (!URDE)
-    return false;
-
   auto &solution = getSolution();
-  auto memberLoc = getConstraintLocator(URDE, ConstraintLocator::Member);
-  auto overload = solution.getOverloadChoiceIfAvailable(memberLoc);
-  if (!overload)
-    return false;
-
-  auto decl = dyn_cast_or_null<VarDecl>(overload->choice.getDecl());
+  auto decl = getDestinationVarDecl(AE, solution);
   if (!decl)
     return false;
 
@@ -938,7 +947,8 @@ bool AttributedFuncToTypeConversionFailure::
   auto destInterfaceFnType = destInterfaceType->castTo<FunctionType>();
   auto param = destInterfaceFnType->getParams()[mismatchPosition];
   emitDiagnostic(diag::converting_noattrfunc_contravariant_parameter_position,
-                 mismatchPosition, decl->getName(), param.getParameterType());
+                 mismatchPosition, decl->getName(), param.getParameterType(),
+                 decl->getDescriptiveKind());
 
   auto note = emitDiagnosticAt(decl->getLoc(), diag::add_explicit_escaping,
                                mismatchPosition);

test/Constraints/function_conversion.swift

@@ -57,9 +57,9 @@ func twoFns(_ f: (Int) -> Int, _ g: @escaping (Int) -> Int) {
 takesAny(consumeNoEscape)
 takesAny(consumeEscaping)
 
-var noEscapeParam: ((Int) -> Int) -> () = consumeNoEscape
+var noEscapeParam: ((Int) -> Int) -> () = consumeNoEscape // expected-note {{add explicit @escaping to function parameter}}{{21-21=@escaping }}
 var escapingParam: (@escaping (Int) -> Int) -> () = consumeEscaping
-noEscapeParam = escapingParam // expected-error {{converting non-escaping value to '(Int) -> Int' may allow it to escape}}
+noEscapeParam = escapingParam // expected-error {{converting escaping to non-escaping functions of type '(Int) -> Int' in parameter position #0 of function type var 'noEscapeParam' is not allowed}}
 
 escapingParam = takesAny
 noEscapeParam = takesAny // expected-error {{converting non-escaping value to 'Any' may allow it to escape}}

test/attr/attr_escaping.swift

@@ -153,7 +153,7 @@ class FooClass {
   }
   var computedEscaping : (@escaping ()->Int)->Void {
     get { return stored! }
-    set(newValue) { stored = newValue } // expected-error{{converting escaping to non-escaping functions of type '() -> Int' in parameter position #0 of function type member 'stored' is not allowed}}
+    set(newValue) { stored = newValue } // expected-error{{converting escaping to non-escaping functions of type '() -> Int' in parameter position #0 of function type property 'stored' is not allowed}}
   }
 }
 
@@ -231,6 +231,8 @@ extension SR_9760 {
 func foo<T>(_ x: @escaping T) {} // expected-error 1{{@escaping attribute only applies to function types}}
 
 // SR-14720
+var global: ((() -> Void) -> Void)? = nil // expected-note {{add explicit @escaping to function parameter #0}} {{15-15=@escaping }}
+
 class SR14720 {
   let ok: (@escaping () -> Void) -> Void // OK
   let callback: (() -> Void) -> Void // expected-note {{add explicit @escaping to function parameter #0}} {{18-18=@escaping }}
@@ -239,19 +241,23 @@ class SR14720 {
   let callbackOpt: ((() -> Void) -> Void)? // expected-note{{add explicit @escaping to function parameter #0}} {{22-22=@escaping }}
 
   init(f: @escaping (@escaping() -> Void) -> Void) {
-    self.callback = f // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #0 of function type member 'callback' is not allowed}}
+    self.callback = f // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #0 of function type property 'callback' is not allowed}}
     self.ok = f // Ok
   }
 
   init(af: @escaping (@escaping() -> Void) -> Void) {
-    self.callbackOpt = af // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #0 of function type member 'callbackOpt' is not allowed}}
+    self.callbackOpt = af // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #0 of function type property 'callbackOpt' is not allowed}}
+  }
+
+  init(ag: @escaping (@escaping() -> Void) -> Void) {
+    global = ag // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #0 of function type var 'global' is not allowed}}
   }
 
   init(a: @escaping (@escaping () -> Void) -> Void) {
-    self.callbackAuto = a // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #0 of function type member 'callbackAuto' is not allowed}}
+    self.callbackAuto = a // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #0 of function type property 'callbackAuto' is not allowed}}
   }
 
   init(f: @escaping (() -> Void, @escaping() -> Void) -> Void) {
-    self.callback1 = f // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #1 of function type member 'callback1' is not allowed}}
+    self.callback1 = f // expected-error{{converting escaping to non-escaping functions of type '() -> Void' in parameter position #1 of function type property 'callback1' is not allowed}}
   }
 }