[ConstraintSystem] Add a tailored diagnostic for conversion of non-escaping parameter to dependent member type

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -3081,7 +3081,7 @@ ERROR(passing_noescape_to_escaping,none,
       (Identifier))
 ERROR(converting_noespace_param_to_generic_type,none,
       "converting non-escaping parameter %0 to generic parameter %1 may allow it to escape",
-      (Identifier, Identifier))
+      (Identifier, Type))
 ERROR(assigning_noescape_to_escaping,none,
       "assigning non-escaping parameter %0 to an @escaping closure",
       (Identifier))

lib/Sema/CSDiagnostics.cpp

@@ -463,6 +463,16 @@ bool NoEscapeFuncToTypeConversionFailure::diagnoseParameterUse() const {
   auto *locator = getLocator();
   auto diagnostic = diag::general_noescape_to_escaping;
 
+  auto getGenericParamType =
+      [](TypeVariableType *typeVar) -> GenericTypeParamType * {
+    auto *locator = typeVar->getImpl().getLocator();
+    if (locator->isForGenericParameter()) {
+      const auto &GP = locator->getPath().back();
+      return GP.getGenericParameter();
+    }
+    return nullptr;
+  };
+
   ParamDecl *PD = nullptr;
   if (auto *DRE = dyn_cast<DeclRefExpr>(anchor)) {
     PD = dyn_cast<ParamDecl>(DRE->getDecl());
@@ -480,17 +490,32 @@ bool NoEscapeFuncToTypeConversionFailure::diagnoseParameterUse() const {
         (path.back().getKind() == ConstraintLocator::ApplyArgToParam)) {
       if (auto paramType =
               getParameterTypeFor(getRawAnchor(), path.back().getValue2())) {
-        // If this is a situation when non-escaping parameter is passed
-        // to the argument which represents generic parameter, there is
-        // a tailored diagnostic for that.
-        if (auto *GP = paramType->getAs<GenericTypeParamType>()) {
-          emitDiagnostic(anchor->getLoc(),
-                         diag::converting_noespace_param_to_generic_type,
-                         PD->getName(), GP->getName());
-
-          emitDiagnostic(GP->getDecl(),
-                         diag::generic_parameters_always_escaping);
-          return true;
+        if (paramType->isTypeVariableOrMember()) {
+          auto diagnoseGenericParamFailure = [&](Type genericParam,
+                                                 GenericTypeParamDecl *decl) {
+            emitDiagnostic(anchor->getLoc(),
+                           diag::converting_noespace_param_to_generic_type,
+                           PD->getName(), genericParam);
+
+            emitDiagnostic(decl, diag::generic_parameters_always_escaping);
+          };
+
+          // If this is a situation when non-escaping parameter is passed
+          // to the argument which represents generic parameter, there is
+          // a tailored diagnostic for that.
+
+          if (auto *DMT = paramType->getAs<DependentMemberType>()) {
+            auto baseTy = DMT->getBase()->castTo<TypeVariableType>();
+            diagnoseGenericParamFailure(resolveType(DMT),
+                                        getGenericParamType(baseTy)->getDecl());
+            return true;
+          }
+
+          auto *typeVar = paramType->getAs<TypeVariableType>();
+          if (auto *GP = getGenericParamType(typeVar)) {
+            diagnoseGenericParamFailure(GP, GP->getDecl());
+            return true;
+          }
         }
       }
 
@@ -554,17 +579,7 @@ Type NoEscapeFuncToTypeConversionFailure::getParameterTypeFor(
 
   if (auto *fnType = choice->openedType->getAs<FunctionType>()) {
     const auto &param = fnType->getParams()[paramIdx];
-
-    auto paramType = param.getPlainType();
-    if (auto *typeVar = paramType->getAs<TypeVariableType>()) {
-      auto *locator = typeVar->getImpl().getLocator();
-      if (locator->isForGenericParameter()) {
-        const auto &GP = locator->getPath().back();
-        return GP.getGenericParameter();
-      }
-    }
-
-    return paramType;
+    return param.getPlainType();
   }
 
   return Type();

test/Constraints/function.swift

@@ -106,3 +106,22 @@ func foo(block: () -> (), other: () -> Int) {
   takesAny(block)  // expected-error {{converting non-escaping value to 'Any' may allow it to escape}}
   takesAny(other) // expected-error {{converting non-escaping value to 'Any' may allow it to escape}}
 }
+
+protocol P {
+  associatedtype U
+}
+
+func test_passing_noescape_function_to_dependent_member() {
+  struct S<T : P> { // expected-note {{generic parameters are always considered '@escaping'}}
+    func foo(_: T.U) {}
+  }
+
+  struct Q : P {
+    typealias U = () -> Int
+  }
+
+  func test(_ s: S<Q>, fn: () -> Int) {
+    s.foo(fn)
+    // expected-error@-1 {{converting non-escaping parameter 'fn' to generic parameter 'Q.U' (aka '() -> Int') may allow it to escape}}
+  }
+}